verdaccio
Version:
A lightweight private npm proxy registry
613 lines (590 loc) • 81.6 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _assert = _interopRequireDefault(require("assert"));
var _async = _interopRequireDefault(require("async"));
var _debug = _interopRequireDefault(require("debug"));
var _lodash = _interopRequireDefault(require("lodash"));
var _stream = _interopRequireDefault(require("stream"));
var _config = require("@verdaccio/config");
var _core = require("@verdaccio/core");
var _loaders = require("@verdaccio/loaders");
var _localStorageLegacy = _interopRequireDefault(require("@verdaccio/local-storage-legacy"));
var _searchIndexer = require("@verdaccio/search-indexer");
var _streams = require("@verdaccio/streams");
var _logger = require("../lib/logger");
var _constants = require("./constants");
var _localStorage = _interopRequireDefault(require("./local-storage"));
var _metadataUtils = require("./metadata-utils");
var _storageUtils = require("./storage-utils");
var _upStorage = _interopRequireDefault(require("./up-storage"));
var _uplinkUtil = require("./uplink-util");
var _utils = require("./utils");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const debug = (0, _debug.default)('verdaccio:storage');
class Storage {
constructor(config) {
this.config = config;
this.uplinks = (0, _uplinkUtil.setupUpLinks)(config);
this.logger = _logger.logger;
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
this.localStorage = null;
}
async init(config, filters) {
if (this.localStorage === null) {
this.filters = filters;
const storageInstance = await this.loadStorage(config, this.logger);
this.localStorage = new _localStorage.default(this.config, _logger.logger, storageInstance);
await this.localStorage.getSecret(config);
debug('initialization completed');
} else {
debug('storage has been already initialized');
}
if (!this.filters) {
this.filters = await (0, _loaders.asyncLoadPlugin)(this.config.filters, {
config: this.config,
logger: this.logger
}, plugin => {
return typeof plugin.filter_metadata !== 'undefined';
}, true, this.config?.serverSettings?.pluginPrefix, _core.PLUGIN_CATEGORY.FILTER);
debug('filters available %o', this.filters.length);
}
}
async loadStorage(config, logger) {
const Storage = await this.loadStorePlugin();
if (_lodash.default.isNil(Storage)) {
(0, _assert.default)(this.config.storage, 'CONFIG: storage path not defined');
debug('no custom storage found, loading default storage @verdaccio/local-storage');
const localStorage = new _localStorageLegacy.default(config, logger);
logger.info({
name: '@verdaccio/local-storage',
pluginCategory: _core.PLUGIN_CATEGORY.STORAGE
}, 'plugin @{name} successfully loaded (@{pluginCategory})');
return localStorage;
}
return Storage;
}
async loadStorePlugin() {
const plugins = await (0, _loaders.asyncLoadPlugin)(this.config.store, {
config: this.config,
logger: this.logger
}, plugin => {
return typeof plugin.getPackageStorage !== 'undefined';
}, true, this.config?.serverSettings?.pluginPrefix, _core.PLUGIN_CATEGORY.STORAGE);
if (plugins.length > 1) {
this.logger.warn('more than one storage plugins has been detected, multiple storage are not supported, one will be selected automatically');
}
return _lodash.default.head(plugins);
}
/**
* Add a {name} package to a system
Function checks if package with the same name is available from uplinks.
If it isn't, we create package locally
Used storages: local (write) && uplinks
*/
async addPackage(name, metadata, callback) {
try {
await (0, _storageUtils.checkPackageLocal)(name, this.localStorage);
await (0, _storageUtils.checkPackageRemote)(name, this._isAllowPublishOffline(), this._syncUplinksMetadata.bind(this));
await (0, _storageUtils.publishPackage)(name, metadata, this.localStorage);
callback();
} catch (err) {
callback(err);
}
}
_isAllowPublishOffline() {
return typeof this.config.publish !== 'undefined' && _lodash.default.isBoolean(this.config.publish.allow_offline) && this.config.publish.allow_offline;
}
readTokens(filter) {
return this.localStorage.readTokens(filter);
}
saveToken(token) {
return this.localStorage.saveToken(token);
}
deleteToken(user, tokenKey) {
return this.localStorage.deleteToken(user, tokenKey);
}
/**
* Add a new version of package {name} to a system
Used storages: local (write)
*/
addVersion(name, version, metadata, tag, callback) {
this.localStorage.addVersion(name, version, metadata, tag, callback);
}
/**
* Tags a package version with a provided tag
Used storages: local (write)
*/
mergeTags(name, tagHash, callback) {
this.localStorage.mergeTags(name, tagHash, callback);
}
/**
* Change an existing package (i.e. unpublish one version)
Function changes a package info from local storage and all uplinks with write access./
Used storages: local (write)
*/
changePackage(name, metadata, revision, callback) {
this.localStorage.changePackage(name, metadata, revision, callback);
}
/**
* Remove a package from a system
Function removes a package from local storage
Used storages: local (write)
*/
removePackage(name, callback) {
this.localStorage.removePackage(name, callback);
// update the indexer
_searchIndexer.SearchMemoryIndexer.remove(name).catch(reason => {
debug('indexer has failed on remove item %o', reason);
_logger.logger.error('indexer has failed on remove item');
});
}
/**
Remove a tarball from a system
Function removes a tarball from local storage.
Tarball in question should not be linked to in any existing
versions, i.e. package version should be unpublished first.
Used storage: local (write)
*/
removeTarball(name, filename, revision, callback) {
this.localStorage.removeTarball(name, filename, revision, callback);
}
/**
* Upload a tarball for {name} package
Function is synchronous and returns a WritableStream
Used storages: local (write)
*/
addTarball(name, filename) {
return this.localStorage.addTarball(name, filename);
}
hasLocalTarball(name, filename) {
const self = this;
return new Promise((resolve, reject) => {
let localStream = self.localStorage.getTarball(name, filename);
let isOpen = false;
localStream.on('error', err => {
if (isOpen || err.status !== _constants.HTTP_STATUS.NOT_FOUND) {
reject(err);
}
// local reported 404 or request was aborted already
if (localStream) {
localStream.abort();
localStream = null;
}
resolve(false);
});
localStream.on('open', function () {
isOpen = true;
localStream.abort();
localStream = null;
resolve(true);
});
});
}
/**
Get a tarball from a storage for {name} package
Function is synchronous and returns a ReadableStream
Function tries to read tarball locally, if it fails then it reads package
information in order to figure out where we can get this tarball from
Used storages: local || uplink (just one)
*/
getTarball(name, filename) {
const readStream = new _streams.ReadTarball({});
readStream.abort = function () {};
const self = this;
// if someone requesting tarball, it means that we should already have some
// information about it, so fetching package info is unnecessary
// trying local first
// flow: should be IReadTarball
let localStream = self.localStorage.getTarball(name, filename);
let isOpen = false;
localStream.on('error', err => {
if (isOpen || err.status !== _constants.HTTP_STATUS.NOT_FOUND) {
return readStream.emit('error', err);
}
// local reported 404
const err404 = err;
localStream.abort();
localStream = null; // we force for garbage collector
self.localStorage.getPackageMetadata(name, (err, info) => {
if (_lodash.default.isNil(err) && info._distfiles && _lodash.default.isNil(info._distfiles[filename]) === false) {
// information about this file exists locally
serveFile(info._distfiles[filename]);
} else {
// we know nothing about this file, trying to get information elsewhere
self._syncUplinksMetadata(name, info, {}, (err, info) => {
if (_lodash.default.isNil(err) === false) {
return readStream.emit('error', err);
}
if (_lodash.default.isNil(info._distfiles) || _lodash.default.isNil(info._distfiles[filename])) {
return readStream.emit('error', err404);
}
serveFile(info._distfiles[filename]);
});
}
});
});
localStream.on('content-length', function (v) {
readStream.emit('content-length', v);
});
localStream.on('open', function () {
isOpen = true;
localStream.pipe(readStream);
});
return readStream;
/**
* Fetch and cache local/remote packages.
* @param {Object} file define the package shape
*/
function serveFile(file) {
let uplink = null;
for (const uplinkId in self.uplinks) {
if ((0, _config.hasProxyTo)(name, uplinkId, self.config.packages)) {
uplink = self.uplinks[uplinkId];
}
}
if (uplink == null) {
uplink = new _upStorage.default({
url: file.url,
cache: true,
_autogenerated: true
}, self.config);
}
let savestream = null;
if (uplink.config.cache) {
savestream = self.localStorage.addTarball(name, filename);
}
let on_open = function () {
// prevent it from being called twice
on_open = function () {};
const rstream2 = uplink.fetchTarball(file.url);
rstream2.on('error', function (err) {
if (savestream) {
savestream.abort();
}
savestream = null;
readStream.emit('error', err);
});
rstream2.on('end', function () {
if (savestream) {
savestream.done();
}
});
rstream2.on('content-length', function (v) {
readStream.emit('content-length', v);
if (savestream) {
savestream.emit('content-length', v);
}
});
rstream2.pipe(readStream);
if (savestream) {
rstream2.pipe(savestream);
}
};
if (savestream) {
savestream.on('open', function () {
on_open();
});
savestream.on('error', function (err) {
self.logger.warn({
err: err,
fileName: file
}, 'error saving file @{fileName}: @{err.message}\n@{err.stack}');
if (savestream) {
savestream.abort();
}
savestream = null;
on_open();
});
} else {
on_open();
}
}
}
/**
Retrieve a package metadata for {name} package
Function invokes localStorage.getPackage and uplink.get_package for every
uplink with proxy_access rights against {name} and combines results
into one json object
Used storages: local && uplink (proxy_access)
* @param {object} options
* @property {string} options.name Package Name
* @property {object} options.req Express `req` object
* @property {boolean} options.keepUpLinkData keep up link info in package meta, last update, etc.
* @property {function} options.callback Callback for receive data
*/
getPackage(options) {
this.localStorage.getPackageMetadata(options.name, (err, data) => {
if (err && (!err.status || err.status >= _constants.HTTP_STATUS.INTERNAL_ERROR)) {
// report internal errors right away
return options.callback(err);
}
this._syncUplinksMetadata(options.name, data, {
req: options.req,
uplinksLook: options.uplinksLook
}, function getPackageSynUpLinksCallback(err, result, uplinkErrors) {
if (err) {
return options.callback(err);
}
(0, _utils.normalizeDistTags)((0, _storageUtils.cleanUpLinksRef)(options.keepUpLinkData, result));
// npm can throw if this field doesn't exist
result._attachments = {};
if (options.abbreviated === true) {
options.callback(null, (0, _storageUtils.convertAbbreviatedManifest)(result), uplinkErrors);
} else {
options.callback(null, result, uplinkErrors);
}
});
});
}
/**
Retrieve remote and local packages more recent than {startkey}
Function streams all packages from all uplinks first, and then
local packages.
Note that local packages could override registry ones just because
they appear in JSON last. That's a trade-off we make to avoid
memory issues.
Used storages: local && uplink (proxy_access)
* @param {*} startkey
* @param {*} options
* @return {Stream}
*/
search(startkey, options) {
const self = this;
const searchStream = new _stream.default.PassThrough({
objectMode: true
});
_async.default.eachSeries(Object.keys(this.uplinks), function (up_name, cb) {
// shortcut: if `local=1` is supplied, don't call uplinks
if (options.req?.query?.local !== undefined) {
return cb();
}
_logger.logger.info(`search for uplink ${up_name}`);
// search by keyword for each uplink
const uplinkStream = self.uplinks[up_name].search(options);
// join uplink stream with streams PassThrough
uplinkStream.pipe(searchStream, {
end: false
});
uplinkStream.on('error', function (err) {
self.logger.error({
err: err
}, 'uplink error: @{err.message}');
cb();
// to avoid call callback more than once
cb = function () {};
});
uplinkStream.on('end', function () {
cb();
// to avoid call callback more than once
cb = function () {};
});
searchStream.abort = function () {
if (uplinkStream.abort) {
uplinkStream.abort();
}
cb();
// to avoid call callback more than once
cb = function () {};
};
},
// executed after all series
function () {
// attach a local search results
const localSearchStream = self.localStorage.search(startkey, options);
searchStream.abort = function () {
localSearchStream.abort();
};
localSearchStream.pipe(searchStream, {
end: true
});
localSearchStream.on('error', function (err) {
self.logger.error({
err: err
}, 'search error: @{err.message}');
searchStream.end();
});
});
return searchStream;
}
/**
* Retrieve only private local packages
* @param {*} callback
*/
getLocalDatabase(callback) {
const self = this;
this.localStorage.storagePlugin.get((err, locals) => {
if (err) {
callback(err);
}
const packages = [];
const getPackage = function (itemPkg) {
self.localStorage.getPackageMetadata(locals[itemPkg], function (err, pkgMetadata) {
if (_lodash.default.isNil(err)) {
const latest = pkgMetadata[_constants.DIST_TAGS].latest;
if (latest && pkgMetadata.versions[latest]) {
const version = pkgMetadata.versions[latest];
const timeList = pkgMetadata.time;
const time = timeList[latest];
// @ts-ignore
version.time = time;
// Add for stars api
// @ts-ignore
version.users = pkgMetadata.users;
packages.push(version);
} else {
self.logger.warn({
package: locals[itemPkg]
}, 'package @{package} does not have a "latest" tag?');
}
}
if (itemPkg >= locals.length - 1) {
callback(null, packages);
} else {
getPackage(itemPkg + 1);
}
});
};
if (locals.length) {
getPackage(0);
} else {
callback(null, []);
}
});
}
/**
* Function fetches package metadata from uplinks and synchronizes it with local data
if package is available locally, it MUST be provided in pkginfo
returns callback(err, result, uplink_errors)
*/
_syncUplinksMetadata(name, packageInfo, options, callback) {
let found = true;
const self = this;
const upLinks = [];
const hasToLookIntoUplinks = _lodash.default.isNil(options.uplinksLook) || options.uplinksLook;
if (!packageInfo) {
found = false;
packageInfo = (0, _storageUtils.generatePackageTemplate)(name);
}
for (const uplink in this.uplinks) {
if ((0, _config.hasProxyTo)(name, uplink, this.config.packages) && hasToLookIntoUplinks) {
upLinks.push(this.uplinks[uplink]);
}
}
_async.default.map(upLinks, (upLink, cb) => {
const _options = Object.assign({}, options);
const upLinkMeta = packageInfo._uplinks[upLink.upname];
if ((0, _utils.isObject)(upLinkMeta)) {
const fetched = upLinkMeta.fetched;
if (fetched && Date.now() - fetched < upLink.maxage) {
return cb();
}
_options.etag = upLinkMeta.etag;
}
upLink.getRemoteMetadata(name, _options, (err, upLinkResponse, eTag) => {
if (err && err.remoteStatus === 304) {
upLinkMeta.fetched = Date.now();
}
if (err || !upLinkResponse) {
return cb(null, [err || _utils.ErrorCode.getInternalError('no data')]);
}
try {
upLinkResponse = _core.validationUtils.normalizeMetadata(upLinkResponse, name);
} catch (err) {
self.logger.error({
sub: 'out',
err: err
}, 'package.json validating error @{!err.message}\n@{err.stack}');
return cb(null, [err]);
}
packageInfo._uplinks[upLink.upname] = {
etag: eTag,
fetched: Date.now()
};
packageInfo = (0, _storageUtils.mergeUplinkTimeIntoLocal)(packageInfo, upLinkResponse);
(0, _uplinkUtil.updateVersionsHiddenUpLink)(upLinkResponse.versions, upLink);
try {
(0, _metadataUtils.mergeVersions)(packageInfo, upLinkResponse);
} catch (err) {
self.logger.error({
sub: 'out',
err: err
}, 'package.json parsing error @{!err.message}\n@{err.stack}');
return cb(null, [err]);
}
// if we got to this point, assume that the correct package exists
// on the uplink
found = true;
cb();
});
},
// @ts-ignore
(err, upLinksErrors) => {
(0, _assert.default)(!err && Array.isArray(upLinksErrors));
// Check for connection timeout or reset errors with uplink(s)
// (these should be handled differently from the package not being found)
if (!found) {
let uplinkTimeoutError;
for (let i = 0; i < upLinksErrors.length; i++) {
if (upLinksErrors[i]) {
for (let j = 0; j < upLinksErrors[i].length; j++) {
if (upLinksErrors[i][j]) {
const code = upLinksErrors[i][j].code;
if (code === 'ETIMEDOUT' || code === 'ESOCKETTIMEDOUT' || code === 'ECONNRESET') {
uplinkTimeoutError = true;
break;
}
}
}
}
}
if (uplinkTimeoutError) {
return callback(_utils.ErrorCode.getServiceUnavailable(), null, upLinksErrors);
}
return callback(_utils.ErrorCode.getNotFound(_constants.API_ERROR.NO_PACKAGE), null, upLinksErrors);
}
if (upLinks.length === 0) {
return callback(null, packageInfo);
}
self.localStorage.updateVersions(name, packageInfo, async (err, packageJsonLocal) => {
if (err) {
return callback(err);
}
// Any error here will cause a 404, like an uplink error. This is likely the right thing to do
// as a broken filter is a security risk.
const filterErrors = [];
// This MUST be done serially and not in parallel as they modify packageJsonLocal
for (const filter of self.filters ?? []) {
try {
// These filters can assume it's save to modify packageJsonLocal and return it directly for
// performance (i.e. need not be pure)
packageJsonLocal = await filter.filter_metadata(packageJsonLocal);
} catch (err) {
filterErrors.push(err);
}
}
callback(null, packageJsonLocal, _lodash.default.concat(upLinksErrors, filterErrors));
});
});
}
/**
* Set a hidden value for each version.
* @param {Array} versions list of version
* @param {String} upLink uplink name
* @private
*/
_updateVersionsHiddenUpLink(versions, upLink) {
for (const i in versions) {
if (Object.prototype.hasOwnProperty.call(versions, i)) {
const version = versions[i];
// holds a "hidden" value to be used by the package storage.
version[Symbol.for('__verdaccio_uplink')] = upLink.upname;
}
}
}
}
var _default = exports.default = Storage;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_assert","_interopRequireDefault","require","_async","_debug","_lodash","_stream","_config","_core","_loaders","_localStorageLegacy","_searchIndexer","_streams","_logger","_constants","_localStorage","_metadataUtils","_storageUtils","_upStorage","_uplinkUtil","_utils","e","__esModule","default","debug","buildDebug","Storage","constructor","config","uplinks","setupUpLinks","logger","localStorage","init","filters","storageInstance","loadStorage","LocalStorage","getSecret","asyncLoadPlugin","plugin","filter_metadata","serverSettings","pluginPrefix","PLUGIN_CATEGORY","FILTER","length","loadStorePlugin","_","isNil","assert","storage","LocalDatabasePlugin","info","name","pluginCategory","STORAGE","plugins","store","getPackageStorage","warn","head","addPackage","metadata","callback","checkPackageLocal","checkPackageRemote","_isAllowPublishOffline","_syncUplinksMetadata","bind","publishPackage","err","publish","isBoolean","allow_offline","readTokens","filter","saveToken","token","deleteToken","user","tokenKey","addVersion","version","tag","mergeTags","tagHash","changePackage","revision","removePackage","SearchMemoryIndexer","remove","catch","reason","error","removeTarball","filename","addTarball","hasLocalTarball","self","Promise","resolve","reject","localStream","getTarball","isOpen","on","status","HTTP_STATUS","NOT_FOUND","abort","readStream","ReadTarball","emit","err404","getPackageMetadata","_distfiles","serveFile","v","pipe","file","uplink","uplinkId","hasProxyTo","packages","ProxyStorage","url","cache","_autogenerated","savestream","on_open","rstream2","fetchTarball","done","fileName","getPackage","options","data","INTERNAL_ERROR","req","uplinksLook","getPackageSynUpLinksCallback","result","uplinkErrors","normalizeDistTags","cleanUpLinksRef","keepUpLinkData","_attachments","abbreviated","convertAbbreviatedManifest","search","startkey","searchStream","Stream","PassThrough","objectMode","async","eachSeries","Object","keys","up_name","cb","query","local","undefined","uplinkStream","end","localSearchStream","getLocalDatabase","storagePlugin","get","locals","itemPkg","pkgMetadata","latest","DIST_TAGS","versions","timeList","time","users","push","package","packageInfo","found","upLinks","hasToLookIntoUplinks","generatePackageTemplate","map","upLink","_options","assign","upLinkMeta","_uplinks","upname","isObject","fetched","Date","now","maxage","etag","getRemoteMetadata","upLinkResponse","eTag","remoteStatus","ErrorCode","getInternalError","validationUtils","normalizeMetadata","sub","mergeUplinkTimeIntoLocal","updateVersionsHiddenUpLink","mergeVersions","upLinksErrors","Array","isArray","uplinkTimeoutError","i","j","code","getServiceUnavailable","getNotFound","API_ERROR","NO_PACKAGE","updateVersions","packageJsonLocal","filterErrors","concat","_updateVersionsHiddenUpLink","prototype","hasOwnProperty","call","Symbol","for","_default","exports"],"sources":["../../src/lib/storage.ts"],"sourcesContent":["import assert from 'assert';\nimport async, { AsyncResultArrayCallback } from 'async';\nimport buildDebug from 'debug';\nimport _ from 'lodash';\nimport Stream from 'stream';\n\nimport { hasProxyTo } from '@verdaccio/config';\nimport { PLUGIN_CATEGORY, pluginUtils, validationUtils } from '@verdaccio/core';\nimport { asyncLoadPlugin } from '@verdaccio/loaders';\nimport LocalDatabasePlugin from '@verdaccio/local-storage-legacy';\nimport { SearchMemoryIndexer } from '@verdaccio/search-indexer';\nimport { ReadTarball } from '@verdaccio/streams';\nimport {\n  Callback,\n  Config,\n  DistFile,\n  Logger,\n  Manifest,\n  MergeTags,\n  Package,\n  Version,\n  Versions,\n} from '@verdaccio/types';\nimport { GenericBody, Token, TokenFilter } from '@verdaccio/types';\n\nimport { StoragePluginLegacy } from '../../types/custom';\nimport { logger } from '../lib/logger';\nimport { IPluginFilters, ISyncUplinks, StringValue } from '../types';\nimport { API_ERROR, DIST_TAGS, HTTP_STATUS } from './constants';\nimport LocalStorage, { StoragePlugin } from './local-storage';\nimport { mergeVersions } from './metadata-utils';\nimport {\n  checkPackageLocal,\n  checkPackageRemote,\n  cleanUpLinksRef,\n  convertAbbreviatedManifest,\n  generatePackageTemplate,\n  mergeUplinkTimeIntoLocal,\n  publishPackage,\n} from './storage-utils';\nimport ProxyStorage from './up-storage';\nimport { setupUpLinks, updateVersionsHiddenUpLink } from './uplink-util';\nimport { ErrorCode, isObject, normalizeDistTags } from './utils';\n\nconst debug = buildDebug('verdaccio:storage');\n\nclass Storage {\n  public localStorage: LocalStorage;\n  public config: Config;\n  public logger: Logger;\n  public uplinks: Record<string, ProxyStorage>;\n  public filters: IPluginFilters | undefined;\n\n  public constructor(config: Config) {\n    this.config = config;\n    this.uplinks = setupUpLinks(config);\n    this.logger = logger;\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    this.localStorage = null;\n  }\n\n  public async init(config: Config, filters?: IPluginFilters): Promise<void> {\n    if (this.localStorage === null) {\n      this.filters = filters;\n      const storageInstance = await this.loadStorage(config, this.logger);\n      this.localStorage = new LocalStorage(this.config, logger, storageInstance);\n      await this.localStorage.getSecret(config);\n      debug('initialization completed');\n    } else {\n      debug('storage has been already initialized');\n    }\n\n    if (!this.filters) {\n      this.filters = await asyncLoadPlugin<pluginUtils.ManifestFilter<unknown>>(\n        this.config.filters,\n        {\n          config: this.config,\n          logger: this.logger,\n        },\n        (plugin: pluginUtils.ManifestFilter<Config>) => {\n          return typeof plugin.filter_metadata !== 'undefined';\n        },\n        true,\n        this.config?.serverSettings?.pluginPrefix,\n        PLUGIN_CATEGORY.FILTER\n      );\n      debug('filters available %o', this.filters.length);\n    }\n  }\n\n  private async loadStorage(config: Config, logger: Logger): Promise<StoragePlugin> {\n    const Storage = await this.loadStorePlugin();\n    if (_.isNil(Storage)) {\n      assert(this.config.storage, 'CONFIG: storage path not defined');\n      debug('no custom storage found, loading default storage @verdaccio/local-storage');\n      const localStorage = new LocalDatabasePlugin(config, logger);\n      logger.info(\n        { name: '@verdaccio/local-storage', pluginCategory: PLUGIN_CATEGORY.STORAGE },\n        'plugin @{name} successfully loaded (@{pluginCategory})'\n      );\n      return localStorage;\n    }\n    return Storage as StoragePlugin;\n  }\n\n  private async loadStorePlugin(): Promise<StoragePluginLegacy<Config> | undefined> {\n    const plugins: StoragePluginLegacy<Config>[] = await asyncLoadPlugin<\n      pluginUtils.Storage<unknown>\n    >(\n      this.config.store,\n      {\n        config: this.config,\n        logger: this.logger,\n      },\n      (plugin) => {\n        return typeof plugin.getPackageStorage !== 'undefined';\n      },\n      true,\n      this.config?.serverSettings?.pluginPrefix,\n      PLUGIN_CATEGORY.STORAGE\n    );\n\n    if (plugins.length > 1) {\n      this.logger.warn(\n        'more than one storage plugins has been detected, multiple storage are not supported, one will be selected automatically'\n      );\n    }\n\n    return _.head(plugins);\n  }\n\n  /**\n   *  Add a {name} package to a system\n   Function checks if package with the same name is available from uplinks.\n   If it isn't, we create package locally\n   Used storages: local (write) && uplinks\n   */\n  public async addPackage(name: string, metadata: any, callback: any): Promise<void> {\n    try {\n      await checkPackageLocal(name, this.localStorage);\n      await checkPackageRemote(\n        name,\n        this._isAllowPublishOffline(),\n        this._syncUplinksMetadata.bind(this)\n      );\n      await publishPackage(name, metadata, this.localStorage);\n      callback();\n    } catch (err: any) {\n      callback(err);\n    }\n  }\n\n  private _isAllowPublishOffline(): boolean {\n    return (\n      typeof this.config.publish !== 'undefined' &&\n      _.isBoolean(this.config.publish.allow_offline) &&\n      this.config.publish.allow_offline\n    );\n  }\n\n  public readTokens(filter: TokenFilter): Promise<Token[]> {\n    return this.localStorage.readTokens(filter);\n  }\n\n  public saveToken(token: Token): Promise<void> {\n    return this.localStorage.saveToken(token);\n  }\n\n  public deleteToken(user: string, tokenKey: string): Promise<any> {\n    return this.localStorage.deleteToken(user, tokenKey);\n  }\n\n  /**\n   * Add a new version of package {name} to a system\n   Used storages: local (write)\n   */\n  public addVersion(\n    name: string,\n    version: string,\n    metadata: Version,\n    tag: StringValue,\n    callback: Callback\n  ): void {\n    this.localStorage.addVersion(name, version, metadata, tag, callback);\n  }\n\n  /**\n   * Tags a package version with a provided tag\n   Used storages: local (write)\n   */\n  public mergeTags(name: string, tagHash: MergeTags, callback: Callback): void {\n    this.localStorage.mergeTags(name, tagHash, callback);\n  }\n\n  /**\n   * Change an existing package (i.e. unpublish one version)\n   Function changes a package info from local storage and all uplinks with write access./\n   Used storages: local (write)\n   */\n  public changePackage(\n    name: string,\n    metadata: Package,\n    revision: string,\n    callback: Callback\n  ): void {\n    this.localStorage.changePackage(name, metadata, revision, callback);\n  }\n\n  /**\n   * Remove a package from a system\n   Function removes a package from local storage\n   Used storages: local (write)\n   */\n  public removePackage(name: string, callback: Callback): void {\n    this.localStorage.removePackage(name, callback);\n    // update the indexer\n    SearchMemoryIndexer.remove(name).catch((reason) => {\n      debug('indexer has failed on remove item %o', reason);\n      logger.error('indexer has failed on remove item');\n    });\n  }\n\n  /**\n   Remove a tarball from a system\n   Function removes a tarball from local storage.\n   Tarball in question should not be linked to in any existing\n   versions, i.e. package version should be unpublished first.\n   Used storage: local (write)\n   */\n  public removeTarball(name: string, filename: string, revision: string, callback: Callback): void {\n    this.localStorage.removeTarball(name, filename, revision, callback);\n  }\n\n  /**\n   * Upload a tarball for {name} package\n   Function is synchronous and returns a WritableStream\n   Used storages: local (write)\n   */\n  public addTarball(name: string, filename: string) {\n    return this.localStorage.addTarball(name, filename);\n  }\n\n  public hasLocalTarball(name: string, filename: string): Promise<boolean> {\n    const self = this;\n    return new Promise<boolean>((resolve, reject): void => {\n      let localStream: any = self.localStorage.getTarball(name, filename);\n      let isOpen = false;\n      localStream.on('error', (err): any => {\n        if (isOpen || err.status !== HTTP_STATUS.NOT_FOUND) {\n          reject(err);\n        }\n        // local reported 404 or request was aborted already\n        if (localStream) {\n          localStream.abort();\n          localStream = null;\n        }\n        resolve(false);\n      });\n      localStream.on('open', function (): void {\n        isOpen = true;\n        localStream.abort();\n        localStream = null;\n        resolve(true);\n      });\n    });\n  }\n\n  /**\n   Get a tarball from a storage for {name} package\n   Function is synchronous and returns a ReadableStream\n   Function tries to read tarball locally, if it fails then it reads package\n   information in order to figure out where we can get this tarball from\n   Used storages: local || uplink (just one)\n   */\n  public getTarball(name: string, filename: string) {\n    const readStream = new ReadTarball({});\n    readStream.abort = function () {};\n\n    const self = this;\n\n    // if someone requesting tarball, it means that we should already have some\n    // information about it, so fetching package info is unnecessary\n\n    // trying local first\n    // flow: should be IReadTarball\n    let localStream: any = self.localStorage.getTarball(name, filename);\n    let isOpen = false;\n    localStream.on('error', (err): any => {\n      if (isOpen || err.status !== HTTP_STATUS.NOT_FOUND) {\n        return readStream.emit('error', err);\n      }\n\n      // local reported 404\n      const err404 = err;\n      localStream.abort();\n      localStream = null; // we force for garbage collector\n      self.localStorage.getPackageMetadata(name, (err, info: Package): void => {\n        if (_.isNil(err) && info._distfiles && _.isNil(info._distfiles[filename]) === false) {\n          // information about this file exists locally\n          serveFile(info._distfiles[filename]);\n        } else {\n          // we know nothing about this file, trying to get information elsewhere\n          self._syncUplinksMetadata(name, info, {}, (err, info: Package): any => {\n            if (_.isNil(err) === false) {\n              return readStream.emit('error', err);\n            }\n            if (_.isNil(info._distfiles) || _.isNil(info._distfiles[filename])) {\n              return readStream.emit('error', err404);\n            }\n            serveFile(info._distfiles[filename]);\n          });\n        }\n      });\n    });\n    localStream.on('content-length', function (v): void {\n      readStream.emit('content-length', v);\n    });\n    localStream.on('open', function (): void {\n      isOpen = true;\n      localStream.pipe(readStream);\n    });\n    return readStream;\n\n    /**\n     * Fetch and cache local/remote packages.\n     * @param {Object} file define the package shape\n     */\n    function serveFile(file: DistFile): void {\n      let uplink: any = null;\n\n      for (const uplinkId in self.uplinks) {\n        if (hasProxyTo(name, uplinkId, self.config.packages)) {\n          uplink = self.uplinks[uplinkId];\n        }\n      }\n\n      if (uplink == null) {\n        uplink = new ProxyStorage(\n          {\n            url: file.url,\n            cache: true,\n            _autogenerated: true,\n          },\n          self.config\n        );\n      }\n\n      let savestream: any = null;\n      if (uplink.config.cache) {\n        savestream = self.localStorage.addTarball(name, filename);\n      }\n\n      let on_open = function (): void {\n        // prevent it from being called twice\n        on_open = function () {};\n        const rstream2 = uplink.fetchTarball(file.url);\n        rstream2.on('error', function (err): void {\n          if (savestream) {\n            savestream.abort();\n          }\n          savestream = null;\n          readStream.emit('error', err);\n        });\n        rstream2.on('end', function (): void {\n          if (savestream) {\n            savestream.done();\n          }\n        });\n\n        rstream2.on('content-length', function (v): void {\n          readStream.emit('content-length', v);\n          if (savestream) {\n            savestream.emit('content-length', v);\n          }\n        });\n        rstream2.pipe(readStream);\n        if (savestream) {\n          rstream2.pipe(savestream);\n        }\n      };\n\n      if (savestream) {\n        savestream.on('open', function (): void {\n          on_open();\n        });\n\n        savestream.on('error', function (err): void {\n          self.logger.warn(\n            { err: err, fileName: file },\n            'error saving file @{fileName}: @{err.message}\\n@{err.stack}'\n          );\n          if (savestream) {\n            savestream.abort();\n          }\n          savestream = null;\n          on_open();\n        });\n      } else {\n        on_open();\n      }\n    }\n  }\n\n  /**\n   Retrieve a package metadata for {name} package\n   Function invokes localStorage.getPackage and uplink.get_package for every\n   uplink with proxy_access rights against {name} and combines results\n   into one json object\n   Used storages: local && uplink (proxy_access)\n\n   * @param {object} options\n   * @property {string} options.name Package Name\n   * @property {object}  options.req Express `req` object\n   * @property {boolean} options.keepUpLinkData keep up link info in package meta, last update, etc.\n   * @property {function} options.callback Callback for receive data\n   */\n  public getPackage(options): void {\n    this.localStorage.getPackageMetadata(options.name, (err, data): void => {\n      if (err && (!err.status || err.status >= HTTP_STATUS.INTERNAL_ERROR)) {\n        // report internal errors right away\n        return options.callback(err);\n      }\n\n      this._syncUplinksMetadata(\n        options.name,\n        data,\n        { req: options.req, uplinksLook: options.uplinksLook },\n        function getPackageSynUpLinksCallback(err, result: Package, uplinkErrors): void {\n          if (err) {\n            return options.callback(err);\n          }\n\n          normalizeDistTags(cleanUpLinksRef(options.keepUpLinkData, result));\n\n          // npm can throw if this field doesn't exist\n          result._attachments = {};\n          if (options.abbreviated === true) {\n            options.callback(null, convertAbbreviatedManifest(result), uplinkErrors);\n          } else {\n            options.callback(null, result, uplinkErrors);\n          }\n        }\n      );\n    });\n  }\n\n  /**\n   Retrieve remote and local packages more recent than {startkey}\n   Function streams all packages from all uplinks first, and then\n   local packages.\n   Note that local packages could override registry ones just because\n   they appear in JSON last. That's a trade-off we make to avoid\n   memory issues.\n   Used storages: local && uplink (proxy_access)\n   * @param {*} startkey\n   * @param {*} options\n   * @return {Stream}\n   */\n  public search(startkey: string, options: any) {\n    const self = this;\n    const searchStream: any = new Stream.PassThrough({ objectMode: true });\n    async.eachSeries(\n      Object.keys(this.uplinks),\n      function (up_name, cb): void {\n        // shortcut: if `local=1` is supplied, don't call uplinks\n        if (options.req?.query?.local !== undefined) {\n          return cb();\n        }\n        logger.info(`search for uplink ${up_name}`);\n        // search by keyword for each uplink\n        const uplinkStream = self.uplinks[up_name].search(options);\n        // join uplink stream with streams PassThrough\n        uplinkStream.pipe(searchStream, { end: false });\n        uplinkStream.on('error', function (err): void {\n          self.logger.error({ err: err }, 'uplink error: @{err.message}');\n          cb();\n          // to avoid call callback more than once\n          cb = function (): void {};\n        });\n        uplinkStream.on('end', function (): void {\n          cb();\n          // to avoid call callback more than once\n          cb = function (): void {};\n        });\n\n        searchStream.abort = function (): void {\n          if (uplinkStream.abort) {\n            uplinkStream.abort();\n          }\n          cb();\n          // to avoid call callback more than once\n          cb = function (): void {};\n        };\n      },\n      // executed after all series\n      function (): void {\n        // attach a local search results\n        const localSearchStream = self.localStorage.search(startkey, options);\n        searchStream.abort = function (): void {\n          localSearchStream.abort();\n        };\n        localSearchStream.pipe(searchStream, { end: true });\n        localSearchStream.on('error', function (err: any): void {\n          self.logger.error({ err: err }, 'search error: @{err.message}');\n          searchStream.end();\n        });\n      }\n    );\n\n    return searchStream;\n  }\n\n  /**\n   * Retrieve only private local packages\n   * @param {*} callback\n   */\n  public getLocalDatabase(callback: Callback): void {\n    const self = this;\n    this.localStorage.storagePlugin.get((err, locals): void => {\n      if (err) {\n        callback(err);\n      }\n\n      const packages: Version[] = [];\n      const getPackage = function (itemPkg): void {\n        self.localStorage.getPackageMetadata(\n          locals[itemPkg],\n          function (err, pkgMetadata: Package): void {\n            if (_.isNil(err)) {\n              const latest = pkgMetadata[DIST_TAGS].latest;\n              if (latest && pkgMetadata.versions[latest]) {\n                const version: Version = pkgMetadata.versions[latest];\n                const timeList = pkgMetadata.time as GenericBody;\n                const time = timeList[latest];\n                // @ts-ignore\n                version.time = time;\n\n                // Add for stars api\n                // @ts-ignore\n                version.users = pkgMetadata.users;\n\n                packages.push(version);\n              } else {\n                self.logger.warn(\n