@verdaccio/canary 6.3.2-canary.404363f

package/build/lib/storage.js

@@ -0,0 +1,676 @@
+"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;
+
+    // Check if the tarball is allowed by filter plugins before serving.
+    // Filters may block specific versions, so we verify the tarball's version
+    // still exists in the filtered metadata.
+    this._isTarballAllowedByFilters(name, filename).then(async allowed => {
+      if (!allowed) {
+        readStream.emit('error', _utils.ErrorCode.getNotFound(_constants.API_ERROR.NO_PACKAGE));
+        return;
+      }
+
+      // trying local first
+      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
+
+        const lookupFromUplinks = info => {
+          self._syncUplinksMetadata(name, info, {}, (syncErr, syncInfo) => {
+            if (_lodash.default.isNil(syncErr) === false) {
+              return readStream.emit('error', syncErr);
+            }
+            if (_lodash.default.isNil(syncInfo._distfiles) || _lodash.default.isNil(syncInfo._distfiles[filename])) {
+              return readStream.emit('error', err404);
+            }
+            serveFile(syncInfo._distfiles[filename]);
+          });
+        };
+        self.localStorage.getPackageMetadataAsync(name).then(info => {
+          if (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
+            lookupFromUplinks(info);
+          }
+        }, () => {
+          // we know nothing about this file, trying to get information elsewhere
+          lookupFromUplinks(null);
+        });
+      });
+      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) {
+    this.localStorage.storagePlugin.get((err, locals) => {
+      if (err) {
+        return callback(err);
+      }
+      this._collectLocalPackages(locals).then(packages => callback(null, packages), err => callback(err));
+    });
+  }
+
+  /**
+   * Read each local package name, apply filters, and collect the latest version.
+   */
+  async _collectLocalPackages(locals) {
+    const packages = [];
+    for (const name of locals) {
+      try {
+        const pkgMetadata = await this.localStorage.getPackageMetadataAsync(name);
+        const {
+          filteredPackage
+        } = await this._applyFilters(pkgMetadata);
+        const latest = filteredPackage[_constants.DIST_TAGS]?.latest;
+        if (latest && filteredPackage.versions[latest]) {
+          const version = filteredPackage.versions[latest];
+          const timeList = filteredPackage.time;
+          const time = timeList[latest];
+          // @ts-ignore
+          version.time = time;
+
+          // Add for stars api
+          // @ts-ignore
+          version.users = filteredPackage.users;
+          packages.push(version);
+        } else {
+          this.logger.warn({
+            package: name
+          }, 'package @{package} does not have a "latest" tag?');
+        }
+      } catch (err) {
+        this.logger.error({
+          err,
+          package: name
+        }, 'error reading package @{package}');
+      }
+    }
+    return packages;
+  }
+
+  /**
+   * 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
+    async (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) {
+        const {
+          filteredPackage,
+          filterErrors
+        } = await self._applyFilters(packageInfo);
+        return callback(null, filteredPackage, filterErrors);
+      }
+      try {
+        const packageJsonLocal = await self.localStorage.updateVersionsAsync(name, packageInfo);
+        const {
+          filteredPackage,
+          filterErrors
+        } = await self._applyFilters(packageJsonLocal);
+        callback(null, filteredPackage, _lodash.default.concat(upLinksErrors, filterErrors));
+      } catch (err) {
+        callback(err);
+      }
+    });
+  }
+
+  /**
+   * Apply all configured filter plugins to a package manifest sequentially.
+   * Each filter's output is passed as input to the next filter.
+   * Returns the filtered manifest and any errors that occurred.
+   */
+  async _applyFilters(packageInfo) {
+    const filterErrors = [];
+    let filteredPackage = packageInfo;
+    for (const filter of this.filters ?? []) {
+      try {
+        filteredPackage = await filter.filter_metadata(filteredPackage);
+      } catch (err) {
+        filterErrors.push(err);
+      }
+    }
+    return {
+      filteredPackage,
+      filterErrors
+    };
+  }
+
+  /**
+   * Check if a tarball should be served based on filter plugins.
+   * Looks up package metadata, applies filters, and verifies the tarball
+   * still belongs to an allowed version.
+   */
+  async _isTarballAllowedByFilters(name, filename) {
+    if (!this.filters?.length) {
+      return true;
+    }
+    try {
+      const pkgMetadata = await this.localStorage.getPackageMetadataAsync(name);
+      const {
+        filteredPackage
+      } = await this._applyFilters(pkgMetadata);
+      return Object.values(filteredPackage.versions || {}).some(version => version.dist?.tarball?.endsWith('/' + filename));
+    } catch (err) {
+      if (err?.status === _constants.HTTP_STATUS.NOT_FOUND) {
+        // Package not yet cached locally — the request will fall through to uplinks.
+        debug('package %o not cached locally, skipping tarball filter check', name);
+      } else {
+        this.logger.error({
+          package: name,
+          fileName: filename,
+          err
+        }, 'error checking filters for tarball @{fileName} of package @{package}: @{err.message}');
+      }
+      return true;
+    }
+  }
+
+  /**
+   * 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","_isTarballAllowedByFilters","then","allowed","emit","ErrorCode","getNotFound","API_ERROR","NO_PACKAGE","err404","lookupFromUplinks","syncErr","syncInfo","_distfiles","serveFile","getPackageMetadataAsync","v","pipe","file","uplink","uplinkId","hasProxyTo","packages","ProxyStorage","url","cache","_autogenerated","savestream","on_open","rstream2","fetchTarball","done","fileName","getPackage","options","getPackageMetadata","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","_collectLocalPackages","pkgMetadata","filteredPackage","_applyFilters","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","getInternalError","validationUtils","normalizeMetadata","sub","mergeUplinkTimeIntoLocal","updateVersionsHiddenUpLink","mergeVersions","upLinksErrors","Array","isArray","uplinkTimeoutError","i","j","code","getServiceUnavailable","filterErrors","packageJsonLocal","updateVersionsAsync","concat","values","some","dist","tarball","endsWith","_updateVersionsHiddenUpLink","prototype","hasOwnProperty","call","Symbol","for","_default","exports"],"sources":["../../src/lib/storage.ts"],"sourcesContent":["import assert from 'assert';\nimport async 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  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: Manifest,\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    // Check if the tarball is allowed by filter plugins before serving.\n    // Filters may block specific versions, so we verify the tarball's version\n    // still exists in the filtered metadata.\n    this._isTarballAllowedByFilters(name, filename).then(async (allowed) => {\n      if (!allowed) {\n        readStream.emit('error', ErrorCode.getNotFound(API_ERROR.NO_PACKAGE));\n        return;\n      }\n\n      // trying local first\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\n        const lookupFromUplinks = (info: Manifest | null): void => {\n          self._syncUplinksMetadata(\n            name,\n            info as Manifest,\n            {},\n            (syncErr, syncInfo: Manifest): any => {\n              if (_.isNil(syncErr) === false) {\n                return readStream.emit('error', syncErr);\n              }\n              if (_.isNil(syncInfo._distfiles) || _.isNil(syncInfo._distfiles[filename])) {\n                return readStream.emit('error', err404);\n              }\n              serveFile(syncInfo._distfiles[filename]);\n            }\n          );\n        };\n\n        self.localStorage.getPackageMetadataAsync(name).then(\n          (info) => {\n            if (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              lookupFromUplinks(info);\n            }\n          },\n          () => {\n            // we know nothing about this file, trying to get information elsewhere\n            lookupFromUplinks(null);\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    });\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: Manifest, 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    this.localStorage.storagePlugin.get((err, locals): void => {\n      if (err) {\n        return callback(err);\n      }\n\n      this._collectLocalPackages(locals).then(\n        (packages) => callback(null, packages),\n        (err) => callback(err)\n      );\n    });\n  }\n\n  /**\n   * Read each local package name, apply filters, and collect the latest version.\n   */\n  private async _collectLocalPackages(locals: string[]): Promise<Version[]> {\n    const packages: Version[] = [];\n    for (const name of locals) {\n      try {\n        const pkgMetadata = await this.localStorage.getPackageMetadataAsync(name);\n        const { filteredPackage } = await this._applyFilters(pkgMetadata);\n        const latest = filteredPackage[DIST_TAGS]?.latest;\n        if (latest && filteredPackage.versions[latest]) {\n          const version: Version = filteredPackage.versions[latest];\n          const timeList = filteredPackage.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 = filteredPackage.users;\n\n          packages.push(version);\n        } else {\n          this.logger.warn({ package: name }, 'package @{package} does not have a \"latest\" tag?');\n        }\n      } catch (err) {\n        this.logger.error({ err, package: name }, 'error reading package @{package}');\n      }\n    }\n    return packages;\n  }\n\n  /**\n   * Function fetches package metadata from uplinks and synchronizes it with local data\n   if package is available locally, it MUST be provided in pkginfo\n   returns callback(err, result, uplink_errors)\n   */\n  public _syncUplinksMetadata(\n    name: string,\n    packageInfo: Manifest,\n    options: ISyncUplinks,\n    callback: Callback\n  ): void {\n    let found = true;\n    const self = this;\n    const upLinks: ProxyStorage[] = [];\n    const hasToLookIntoUplinks = _.isNil(options.uplinksLook) || options.uplinksLook;\n\n    if (!packageInfo) {\n      found = false;\n      packageInfo = generatePackageTemplate(name);\n    }\n\n    for (const uplink in this.uplinks) {\n      if (hasProxyTo(name, uplink, this.config.packages) && hasToLookIntoUplinks) {\n        upLinks.push(this.uplinks[uplink]);\n      }\n    }\n\n    async.map(\n      upLinks,\n      (upLink: ProxyStorage, cb): void => {\n        const _options = Object.assign({}, options);\n        const upLinkMeta = packageInfo._uplinks[upLink.upname];\n\n        if (isObject(upLinkMeta)) {\n          const fetched = upLinkMeta.fetched;\n\n          if (fetched && Date.now() - fetched < upLink.maxage) {\n            return cb();\n          }\n\n          _options.etag = upLinkMeta.etag;\n        }\n\n        upLink.getRemoteMetadata(name, _options, (err, upLinkResponse, eTag): void => {\n          if (err && err.remoteStatus === 304) {\n            upLinkMeta.fetched = Date.now();\n          }\n\n          if (err || !upLinkResponse) {\n            return cb(null, [err || ErrorCode.getInternalError('no data')]);\n          }\n\n          try {\n            upLinkResponse = validationUtils.normalizeMetadata(upLinkResponse, name);\n          } catch (err) {\n            self.logger.error(\n              {\n                sub: 'out',\n                err: err,\n              },\n              'package.json validating error @{!err.message}\\n@{err.stack}'\n            );\n            return cb(null, [err]);\n          }\n\n          packageInfo._uplinks[upLink.upname] = {\n            etag: eTag,\n            fetched: Date.now(),\n          };\n\n          packageInfo = mergeUplinkTimeIntoLocal(packageInfo, upLinkResponse);\n\n          updateVersionsHiddenUpLink(upLinkResponse.versions, upLink);\n\n          try {\n            mergeVersions(packageInfo, upLinkResponse);\n          } catch (err) {\n            self.logger.error(\n              {\n                sub: 'out',\n                err: err,\n              },\n              'package.json parsing error @{!err.message}\\n@{err.stack}'\n            );\n            return cb(null, [err]);\n          }\n\n          // if we got to this point, assume that the correct package exists\n          // on the uplink\n          found = true;\n          cb();\n        });\n      },\n      // @ts-ignore\n      async (err: Error, upLinksErrors: any): Promise<void> => {\n        assert(!err && Array.isArray(upLinksErrors));\n\n        // Check for connection timeout or reset errors with uplink(s)\n        // (these should be handled differently from the package not being found)\n        if (!found) {\n          let uplinkTimeoutError;\n          for (let i = 0; i < upLinksErrors.length; i++) {\n            if (upLinksErrors[i]) {\n              for (let j = 0; j < upLinksErrors[i].length; j++) {\n                if (upLinksErrors[i][j]) {\n                  const code = upLinksErrors[i][j].code;\n                  if (code === 'ETIMEDOUT' || code === 'ESOCKETTIMEDOUT' || code === 'ECONNRESET') {\n                    uplinkTimeoutError = true;\n                    break;\n                  }\n                }\n              }\n            }\n          }\n\n          if (uplinkTimeoutError) {\n            return callback(ErrorCode.getServiceUnavailable(), null, upLinksErrors);\n          }\n          return callback(ErrorCode.getNotFound(API_ERROR.NO_PACKAGE), null, upLinksErrors);\n        }\n\n        if (upLinks.length === 0) {\n          const { filteredPackage, filterErrors } = await self._applyFilters(\n            packageInfo as Manifest\n          );\n          return callback(null, filteredPackage, filterErrors);\n        }\n\n        try {\n          const packageJsonLocal = await self.localStorage.updateVersionsAsync(name, packageInfo);\n          const { filteredPackage, filterErrors } = await self._applyFilters(packageJsonLocal);\n          callback(null, filteredPackage, _.concat(upLinksErrors, filterErrors));\n        } catch (err) {\n          callback(err);\n        }\n      }\n    );\n  }\n\n  /**\n   * Apply all configured filter plugins to a package manifest sequentially.\n   * Each filter's output is passed as input to the next filter.\n   * Returns the filtered manifest and any errors that occurred.\n   */\n  private async _applyFilters(\n    packageInfo: Manifest\n  ): Promise<{ filteredPackage: Manifest; filterErrors: Error[] }> {\n    const filterErrors: Error[] = [];\n    let filteredPackage = packageInfo;\n    for (const filter of this.filters ?? []) {\n      try {\n        filteredPackage = await filter.filter_metadata(filteredPackage);\n      } catch (err: any) {\n        filterErrors.push(err);\n      }\n    }\n    return { filteredPackage, filterErrors };\n  }\n\n  /**\n   * Check if a tarball should be served based on filter plugins.\n   * Looks up package metadata, applies filters, and verifies the tarball\n   * still belongs to an allowed version.\n   */\n  private async _isTarballAllowedByFilters(name: string, filename: string): Promise<boolean> {\n    if (!this.filters?.length) {\n      return true;\n    }\n\n    try {\n      const pkgMetadata = await this.localStorage.getPackageMetadataAsync(name);\n      const { filteredPackage } = await this._applyFilters(pkgMetadata);\n      return Object.values(filteredPackage.versions || {}).some((version) =>\n        (version as Version).dist?.tarball?.endsWith('/' + filename)\n      );\n    } catch (err: any) {\n      if (err?.status === HTTP_STATUS.NOT_FOUND) {\n        // Package not yet cached locally — the request will fall through to uplinks.\n        debug('package %o not cached locally, skipping tarball filter check', name);\n      } else {\n        this.logger.error(\n          { package: name, fileName: filename, err },\n          'error checking filters for tarball @{fileName} of package @{package}: @{err.message}'\n        );\n      }\n      return true;\n    }\n  }\n\n  /**\n   * Set a hidden value for each version.\n   * @param {Array} versions list of version\n   * @param {String} upLink uplink name\n   * @private\n   */\n  public _updateVersionsHiddenUpLink(versions: Versions, upLink: ProxyStorage): void {\n    for (const i in versions) {\n      if (Object.prototype.hasOwnProperty.call(versions, i)) {\n        const version = versions[i];\n\n        // holds a \"hidden\" value to be used by the package storage.\n        version[Symbol.for('__verdaccio_uplink')] = upLink.upname;\n      }\n    }\n  }\n}\n\nexport default Storage;\n"],"mappings":"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","ignoreList":[]}