@verdaccio/canary 6.3.2-canary.404363f

package/build/lib/local-storage.js

@@ -0,0 +1,760 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _assert = _interopRequireDefault(require("assert"));
+var _debug = _interopRequireDefault(require("debug"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _url = _interopRequireDefault(require("url"));
+var _streams = require("@verdaccio/streams");
+var _utils = require("@verdaccio/utils");
+var _constants = require("./constants");
+var _storageUtils = require("./storage-utils");
+var _utils2 = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const debug = (0, _debug.default)('verdaccio:local-storage');
+/**
+ * Implements Storage interface (same for storage.js, local-storage.js, up-storage.js).
+ */
+class LocalStorage {
+  constructor(config, logger, localStorage) {
+    this.logger = logger;
+    this.config = config;
+    this.storagePlugin = localStorage;
+  }
+  addPackage(name, pkg, callback) {
+    const storage = this._getLocalStorage(name);
+    if (_lodash.default.isNil(storage)) {
+      return callback(_utils2.ErrorCode.getNotFound('this package cannot be added'));
+    }
+    storage.createPackage(name, (0, _storageUtils.generatePackageTemplate)(name), err => {
+      // FIXME: it will be fixed here https://github.com/verdaccio/verdaccio/pull/1360
+      // @ts-ignore
+      if (_lodash.default.isNull(err) === false && (err.code === _constants.STORAGE.FILE_EXIST_ERROR || err.code === _constants.HTTP_STATUS.CONFLICT)) {
+        return callback(_utils2.ErrorCode.getConflict());
+      }
+      const latest = (0, _utils.getLatestVersion)(pkg);
+      if (_lodash.default.isNil(latest) === false && pkg.versions[latest]) {
+        return callback(null, pkg.versions[latest]);
+      }
+      return callback();
+    });
+  }
+
+  /**
+   * Remove package.
+   * @param {*} name
+   * @param {*} callback
+   * @return {Function}
+   */
+  removePackage(name, callback) {
+    const storage = this._getLocalStorage(name);
+    debug('[storage] removing package %o', name);
+    if (_lodash.default.isNil(storage)) {
+      return callback(_utils2.ErrorCode.getNotFound());
+    }
+    storage.readPackage(name, (err, data) => {
+      if (_lodash.default.isNil(err) === false) {
+        if (err.code === _constants.STORAGE.NO_SUCH_FILE_ERROR || err.code === _constants.HTTP_STATUS.NOT_FOUND) {
+          return callback(_utils2.ErrorCode.getNotFound());
+        }
+        return callback(err);
+      }
+      data = (0, _storageUtils.normalizePackage)(data);
+      this.storagePlugin.remove(name, removeFailed => {
+        if (removeFailed) {
+          // This will happen when database is locked
+          this.logger.error({
+            name
+          }, `[storage/removePackage] the database is locked, removed has failed for @{name}`);
+          return callback(_utils2.ErrorCode.getBadData(removeFailed.message));
+        }
+        storage.deletePackage(_constants.STORAGE.PACKAGE_FILE_NAME, err => {
+          if (err) {
+            return callback(err);
+          }
+          const attachments = Object.keys(data._attachments);
+          this._deleteAttachments(storage, attachments, callback);
+        });
+      });
+    });
+  }
+
+  /**
+   * Synchronize remote package info with the local one
+   * @param {*} name
+   * @param {*} packageInfo
+   * @param {*} callback
+   */
+  updateVersions(name, packageInfo, callback) {
+    this._readCreatePackage(name, (err, packageLocalJson) => {
+      if (err) {
+        return callback(err);
+      }
+      let change = false;
+      // updating readme
+      packageLocalJson.readme = (0, _storageUtils.getLatestReadme)(packageInfo);
+      if (packageInfo.readme !== packageLocalJson.readme) {
+        change = true;
+      }
+      for (const versionId in packageInfo.versions) {
+        if (_lodash.default.isNil(packageLocalJson.versions[versionId])) {
+          let version = packageInfo.versions[versionId];
+
+          // we don't keep readme for package versions,
+          // only one readme per package
+          version = (0, _storageUtils.cleanUpReadme)(version);
+          version.contributors = (0, _utils.normalizeContributors)(version.contributors);
+          change = true;
+          packageLocalJson.versions[versionId] = version;
+          if (version.dist && version.dist.tarball) {
+            const urlObject = _url.default.parse(version.dist.tarball);
+            const filename = urlObject.pathname.replace(/^.*\//, '');
+
+            // we do NOT overwrite any existing records
+            if (_lodash.default.isNil(packageLocalJson._distfiles[filename])) {
+              const hash = packageLocalJson._distfiles[filename] = {
+                url: version.dist.tarball,
+                sha: version.dist.shasum
+              };
+              /* eslint spaced-comment: 0 */
+              const upLink = version[Symbol.for('__verdaccio_uplink')];
+              if (_lodash.default.isNil(upLink) === false) {
+                this._updateUplinkToRemoteProtocol(hash, upLink);
+              }
+            }
+          }
+        }
+      }
+      for (const tag in packageInfo[_constants.DIST_TAGS]) {
+        if (!packageLocalJson[_constants.DIST_TAGS][tag] || packageLocalJson[_constants.DIST_TAGS][tag] !== packageInfo[_constants.DIST_TAGS][tag]) {
+          change = true;
+          packageLocalJson[_constants.DIST_TAGS][tag] = packageInfo[_constants.DIST_TAGS][tag];
+        }
+      }
+      for (const up in packageInfo._uplinks) {
+        if (Object.prototype.hasOwnProperty.call(packageInfo._uplinks, up)) {
+          const need_change = !(0, _utils2.isObject)(packageLocalJson._uplinks[up]) || packageInfo._uplinks[up].etag !== packageLocalJson._uplinks[up].etag || packageInfo._uplinks[up].fetched !== packageLocalJson._uplinks[up].fetched;
+          if (need_change) {
+            change = true;
+            packageLocalJson._uplinks[up] = packageInfo._uplinks[up];
+          }
+        }
+      }
+      if ('time' in packageInfo && !_lodash.default.isEqual(packageLocalJson.time, packageInfo.time)) {
+        packageLocalJson.time = packageInfo.time;
+        change = true;
+      }
+      if (change) {
+        debug('updating package %o info', name);
+        this._writePackage(name, packageLocalJson, function (err) {
+          callback(err, packageLocalJson);
+        });
+      } else {
+        callback(null, packageLocalJson);
+      }
+    });
+  }
+
+  /**
+   * Add a new version to a previous local package.
+   * @param {*} name
+   * @param {*} version
+   * @param {*} metadata
+   * @param {*} tag
+   * @param {*} callback
+   */
+  addVersion(name, version, metadata, tag, callback) {
+    this._updatePackage(name, (data, cb) => {
+      // keep only one readme per package
+      data.readme = metadata.readme;
+
+      // TODO: lodash remove
+      metadata = (0, _storageUtils.cleanUpReadme)(metadata);
+      metadata.contributors = (0, _utils.normalizeContributors)(metadata.contributors);
+      const hasVersion = data.versions[version] != null;
+      if (hasVersion) {
+        return cb(_utils2.ErrorCode.getConflict());
+      }
+
+      // if uploaded tarball has a different shasum, it's very likely that we have some kind of error
+      if ((0, _utils2.isObject)(metadata.dist) && _lodash.default.isString(metadata.dist.tarball)) {
+        const tarball = metadata.dist.tarball.replace(/.*\//, '');
+        if ((0, _utils2.isObject)(data._attachments[tarball])) {
+          if (_lodash.default.isNil(data._attachments[tarball].shasum) === false && _lodash.default.isNil(metadata.dist.shasum) === false) {
+            if (data._attachments[tarball].shasum != metadata.dist.shasum) {
+              const errorMessage = `shasum error, ${data._attachments[tarball].shasum} != ${metadata.dist.shasum}`;
+              return cb(_utils2.ErrorCode.getBadRequest(errorMessage));
+            }
+          }
+          const currentDate = new Date().toISOString();
+
+          // some old storage do not have this field #740
+          if (_lodash.default.isNil(data.time)) {
+            data.time = {};
+          }
+          data.time['modified'] = currentDate;
+          if ('created' in data.time === false) {
+            data.time.created = currentDate;
+          }
+          data.time[version] = currentDate;
+          data._attachments[tarball].version = version;
+        }
+      }
+      data.versions[version] = metadata;
+      (0, _utils2.tagVersion)(data, version, tag);
+      this.storagePlugin.add(name, addFailed => {
+        if (addFailed) {
+          return cb(_utils2.ErrorCode.getBadData(addFailed.message));
+        }
+        cb();
+      });
+    }, callback);
+  }
+
+  /**
+   * Merge a new list of tags for a local packages with the existing one.
+   * @param {*} pkgName
+   * @param {*} tags
+   * @param {*} callback
+   */
+  mergeTags(pkgName, tags, callback) {
+    this._updatePackage(pkgName, (data, cb) => {
+      /* eslint guard-for-in: 0 */
+      for (const tag in tags) {
+        // this handle dist-tag rm command
+        if (_lodash.default.isNull(tags[tag])) {
+          delete data[_constants.DIST_TAGS][tag];
+          continue;
+        }
+        if (_lodash.default.isNil(data.versions[tags[tag]])) {
+          return cb(this._getVersionNotFound());
+        }
+        const version = tags[tag];
+        (0, _utils2.tagVersion)(data, version, tag);
+      }
+      cb(null);
+    }, callback);
+  }
+
+  /**
+   * Return version not found
+   * @return {String}
+   * @private
+   */
+  _getVersionNotFound() {
+    return _utils2.ErrorCode.getNotFound(_constants.API_ERROR.VERSION_NOT_EXIST);
+  }
+
+  /**
+   * Return file no available
+   * @return {String}
+   * @private
+   */
+  _getFileNotAvailable() {
+    return _utils2.ErrorCode.getNotFound('no such file available');
+  }
+
+  /**
+   * Update the package metadata, tags and attachments (tarballs).
+   * Note: Currently supports unpublishing and deprecation.
+   * @param {*} name
+   * @param {*} incomingPkg
+   * @param {*} revision
+   * @param {*} callback
+   * @return {Function}
+   */
+  changePackage(name, incomingPkg, revision, callback) {
+    if (!(0, _utils2.isObject)(incomingPkg.versions) || !(0, _utils2.isObject)(incomingPkg[_constants.DIST_TAGS])) {
+      this.logger.error({
+        name
+      }, `changePackage bad data for @{name}`);
+      return callback(_utils2.ErrorCode.getBadData());
+    }
+    debug('changePackage udapting package for %o', name);
+    this._updatePackage(name, (localData, cb) => {
+      for (const version in localData.versions) {
+        const incomingVersion = incomingPkg.versions[version];
+        if (_lodash.default.isNil(incomingVersion)) {
+          this.logger.info({
+            name: name,
+            version: version
+          }, 'unpublishing @{name}@@{version}');
+
+          // FIXME: I prefer return a new object rather mutate the metadata
+          delete localData.versions[version];
+          delete localData.time[version];
+          for (const file in localData._attachments) {
+            if (localData._attachments[file].version === version) {
+              delete localData._attachments[file].version;
+            }
+          }
+        } else if (Object.prototype.hasOwnProperty.call(incomingVersion, 'deprecated')) {
+          const incomingDeprecated = incomingVersion.deprecated;
+          if (incomingDeprecated != localData.versions[version].deprecated) {
+            if (!incomingDeprecated) {
+              this.logger.info({
+                name: name,
+                version: version
+              }, 'undeprecating @{name}@@{version}');
+              delete localData.versions[version].deprecated;
+            } else {
+              this.logger.info({
+                name: name,
+                version: version
+              }, 'deprecating @{name}@@{version}');
+              localData.versions[version].deprecated = incomingDeprecated;
+            }
+            localData.time.modified = new Date().toISOString();
+          }
+        }
+      }
+      localData[_constants.USERS] = incomingPkg[_constants.USERS];
+      localData[_constants.DIST_TAGS] = incomingPkg[_constants.DIST_TAGS];
+      cb(null);
+    }, function (err) {
+      if (err) {
+        return callback(err);
+      }
+      callback();
+    });
+  }
+  /**
+   * Remove a tarball.
+   * @param {*} name
+   * @param {*} filename
+   * @param {*} revision
+   * @param {*} callback
+   */
+  removeTarball(name, filename, revision, callback) {
+    (0, _assert.default)((0, _utils.validateName)(filename));
+    this._updatePackage(name, (data, cb) => {
+      if (data._attachments[filename]) {
+        delete data._attachments[filename];
+        cb(null);
+      } else {
+        cb(this._getFileNotAvailable());
+      }
+    }, err => {
+      if (err) {
+        return callback(err);
+      }
+      const storage = this._getLocalStorage(name);
+      if (storage) {
+        storage.deletePackage(filename, callback);
+      }
+    });
+  }
+
+  /**
+   * Add a tarball.
+   * @param {String} name
+   * @param {String} filename
+   * @return {Stream}
+   */
+  addTarball(name, filename) {
+    (0, _assert.default)((0, _utils.validateName)(filename));
+    let length = 0;
+    const shaOneHash = (0, _utils.createTarballHash)();
+    const uploadStream = new _streams.UploadTarball({});
+    const _transform = uploadStream._transform;
+    const storage = this._getLocalStorage(name);
+    uploadStream.abort = function () {};
+    uploadStream.done = function () {};
+    uploadStream._transform = function (data, ...args) {
+      shaOneHash.update(data);
+      // measure the length for validation reasons
+      length += data.length;
+      const appliedData = [data, ...args];
+      // FIXME: not sure about this approach, tsc complains
+      // @ts-ignore
+      _transform.apply(uploadStream, appliedData);
+    };
+    if (name === '__proto__') {
+      process.nextTick(() => {
+        uploadStream.emit('error', _utils2.ErrorCode.getForbidden());
+      });
+      return uploadStream;
+    }
+    if (!storage) {
+      process.nextTick(() => {
+        uploadStream.emit('error', "can't upload this package");
+      });
+      return uploadStream;
+    }
+    const writeStream = storage.writeTarball(filename);
+    writeStream.on('error', err => {
+      if (err.code === _constants.STORAGE.FILE_EXIST_ERROR || err.code === _constants.HTTP_STATUS.CONFLICT) {
+        uploadStream.emit('error', _utils2.ErrorCode.getConflict());
+        uploadStream.abort();
+      } else if (err.code === _constants.STORAGE.NO_SUCH_FILE_ERROR || err.code === _constants.HTTP_STATUS.NOT_FOUND) {
+        // check if package exists to throw an appropriate message
+        this.getPackageMetadata(name, function (_err) {
+          if (_err) {
+            uploadStream.emit('error', _err);
+          } else {
+            uploadStream.emit('error', err);
+          }
+        });
+      } else {
+        uploadStream.emit('error', err);
+      }
+    });
+    writeStream.on('open', function () {
+      // re-emitting open because it's handled in storage.js
+      uploadStream.emit('open');
+    });
+    writeStream.on('success', () => {
+      this._updatePackage(name, function updater(data, cb) {
+        data._attachments[filename] = {
+          shasum: shaOneHash.digest('hex')
+        };
+        cb(null);
+      }, function (err) {
+        if (err) {
+          uploadStream.emit('error', err);
+        } else {
+          uploadStream.emit('success');
+        }
+      });
+    });
+    uploadStream.abort = function () {
+      writeStream.abort();
+    };
+    uploadStream.done = function () {
+      if (!length) {
+        uploadStream.emit('error', _utils2.ErrorCode.getBadData('refusing to accept zero-length file'));
+        writeStream.abort();
+      } else {
+        writeStream.done();
+      }
+    };
+    uploadStream.pipe(writeStream);
+    return uploadStream;
+  }
+
+  /**
+   * Get a tarball.
+   * @param {*} name
+   * @param {*} filename
+   * @return {ReadTarball}
+   */
+  getTarball(name, filename) {
+    (0, _assert.default)((0, _utils.validateName)(filename));
+    const storage = this._getLocalStorage(name);
+    if (_lodash.default.isNil(storage)) {
+      return this._createFailureStreamResponse();
+    }
+    return this._streamSuccessReadTarBall(storage, filename);
+  }
+
+  /**
+   * Return a stream that emits a read failure.
+   * @private
+   * @return {ReadTarball}
+   */
+  _createFailureStreamResponse() {
+    const stream = new _streams.ReadTarball({});
+    process.nextTick(() => {
+      stream.emit('error', this._getFileNotAvailable());
+    });
+    return stream;
+  }
+
+  /**
+   * Return a stream that emits the tarball data
+   * @param {Object} storage
+   * @param {String} filename
+   * @private
+   * @return {ReadTarball}
+   */
+  _streamSuccessReadTarBall(storage, filename) {
+    const stream = new _streams.ReadTarball({});
+    const readTarballStream = storage.readTarball(filename);
+    const e404 = _utils2.ErrorCode.getNotFound;
+    stream.abort = function () {
+      if (_lodash.default.isNil(readTarballStream) === false) {
+        readTarballStream.abort();
+      }
+    };
+    readTarballStream.on('error', function (err) {
+      if (err.code === _constants.STORAGE.NO_SUCH_FILE_ERROR || err.code === _constants.HTTP_STATUS.NOT_FOUND) {
+        stream.emit('error', e404('no such file available'));
+      } else {
+        stream.emit('error', err);
+      }
+    });
+    readTarballStream.on('content-length', function (content) {
+      stream.emit('content-length', content);
+    });
+    readTarballStream.on('open', function () {
+      // re-emitting open because it's handled in storage.js
+      stream.emit('open');
+      readTarballStream.pipe(stream);
+    });
+    return stream;
+  }
+
+  /**
+   * Retrieve a package by name.
+   * @param {*} name
+   * @param {*} callback
+   * @return {Function}
+   */
+  getPackageMetadata(name, callback = () => {}) {
+    const storage = this._getLocalStorage(name);
+    if (_lodash.default.isNil(storage)) {
+      return callback(_utils2.ErrorCode.getNotFound());
+    }
+    this._readPackage(name, storage, callback);
+  }
+  getPackageMetadataAsync(name) {
+    return new Promise((resolve, reject) => {
+      this.getPackageMetadata(name, (err, metadata) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve(metadata);
+      });
+    });
+  }
+  updateVersionsAsync(name, packageInfo) {
+    return new Promise((resolve, reject) => {
+      this.updateVersions(name, packageInfo, (err, result) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve(result);
+      });
+    });
+  }
+
+  /**
+   * Search a local package.
+   * @param {*} startKey
+   * @param {*} options
+   * @return {Function}
+   */
+  search(startKey, options) {
+    debug('options for search %o', options);
+    const stream = new _streams.ReadTarball({
+      objectMode: true
+    });
+    this._searchEachPackage((item, cb) => {
+      // @ts-ignore
+      if (item.time > parseInt(startKey, 10)) {
+        this.getPackageMetadata(item.name, (err, data) => {
+          if (err) {
+            return cb(err);
+          }
+
+          // @ts-ignore
+          const time = new Date(item.time).toISOString();
+          const result = (0, _storageUtils.prepareSearchPackage)(data, time);
+          if (_lodash.default.isNil(result) === false) {
+            stream.push(result);
+          }
+          cb(null);
+        });
+      } else {
+        cb(null);
+      }
+    }, function onEnd(err) {
+      if (err) {
+        stream.emit('error', err);
+        return;
+      }
+      stream.end();
+    });
+    return stream;
+  }
+
+  /**
+   * Retrieve a wrapper that provide access to the package location.
+   * @param {Object} pkgName package name.
+   * @return {Object}
+   */
+  _getLocalStorage(pkgName) {
+    return this.storagePlugin.getPackageStorage(pkgName);
+  }
+
+  /**
+   * Read a json file from storage.
+   * @param {Object} storage
+   * @param {Function} callback
+   */
+  _readPackage(name, storage, callback) {
+    storage.readPackage(name, (err, result) => {
+      if (err) {
+        if (err.code === _constants.STORAGE.NO_SUCH_FILE_ERROR || err.code === _constants.HTTP_STATUS.NOT_FOUND) {
+          return callback(_utils2.ErrorCode.getNotFound());
+        }
+        return callback(this._internalError(err, _constants.STORAGE.PACKAGE_FILE_NAME, 'error reading'));
+      }
+      callback(err, (0, _storageUtils.normalizePackage)(result));
+    });
+  }
+
+  /**
+   * Walks through each package and calls `on_package` on them.
+   * @param {*} onPackage
+   * @param {*} onEnd
+   */
+  _searchEachPackage(onPackage, onEnd) {
+    // save wait whether plugin still do not support search functionality
+    if (_lodash.default.isNil(this.storagePlugin.search)) {
+      this.logger.warn('plugin search not implemented yet');
+      onEnd();
+    } else {
+      this.storagePlugin.search(onPackage, onEnd, _utils.validateName);
+    }
+  }
+
+  /**
+   * Retrieve either a previous created local package or a boilerplate.
+   * @param {*} pkgName
+   * @param {*} callback
+   * @return {Function}
+   */
+  _readCreatePackage(pkgName, callback) {
+    const storage = this._getLocalStorage(pkgName);
+    if (_lodash.default.isNil(storage)) {
+      this._createNewPackage(pkgName, callback);
+      return;
+    }
+    storage.readPackage(pkgName, (err, data) => {
+      // TODO: race condition
+      if (_lodash.default.isNil(err) === false) {
+        if (err.code === _constants.STORAGE.NO_SUCH_FILE_ERROR || err.code === _constants.HTTP_STATUS.NOT_FOUND) {
+          data = (0, _storageUtils.generatePackageTemplate)(pkgName);
+        } else {
+          return callback(this._internalError(err, _constants.STORAGE.PACKAGE_FILE_NAME, 'error reading'));
+        }
+      }
+      callback(null, (0, _storageUtils.normalizePackage)(data));
+    });
+  }
+  _createNewPackage(name, callback) {
+    return callback(null, (0, _storageUtils.normalizePackage)((0, _storageUtils.generatePackageTemplate)(name)));
+  }
+
+  /**
+   * Handle internal error
+   * @param {*} err
+   * @param {*} file
+   * @param {*} message
+   * @return {Object} Error instance
+   */
+  _internalError(err, file, message) {
+    this.logger.error({
+      err: err,
+      file: file
+    }, `${message}  @{file}: @{!err.message}`);
+    return _utils2.ErrorCode.getInternalError();
+  }
+
+  /**
+   * @param {*} name package name
+   * @param {*} updateHandler function(package, cb) - update function
+   * @param {*} callback callback that gets invoked after it's all updated
+   * @return {Function}
+   */
+  _updatePackage(name, updateHandler, callback) {
+    const storage = this._getLocalStorage(name);
+    if (!storage) {
+      return callback(_utils2.ErrorCode.getNotFound());
+    }
+    storage.updatePackage(name, updateHandler, this._writePackage.bind(this), _storageUtils.normalizePackage, callback);
+  }
+
+  /**
+   * Update the revision (_rev) string for a package.
+   * @param {*} name
+   * @param {*} json
+   * @param {*} callback
+   * @return {Function}
+   */
+  _writePackage(name, json, callback) {
+    const storage = this._getLocalStorage(name);
+    if (_lodash.default.isNil(storage)) {
+      return callback();
+    }
+    storage.savePackage(name, this._setDefaultRevision(json), callback);
+  }
+  _setDefaultRevision(json) {
+    // calculate revision from couch db
+    if (_lodash.default.isString(json._rev) === false) {
+      json._rev = _constants.STORAGE.DEFAULT_REVISION;
+    }
+
+    // this is intended in debug mode we do not want modify the store revision
+    if (_lodash.default.isNil(this.config._debug)) {
+      json._rev = (0, _storageUtils.generateRevision)(json._rev);
+    }
+    return json;
+  }
+  _deleteAttachments(storage, attachments, callback) {
+    debug('[storage/_deleteAttachments] delete attachments total: %o', attachments?.length);
+    const unlinkNext = function (cb) {
+      if (_lodash.default.isEmpty(attachments)) {
+        return cb();
+      }
+      const attachment = attachments.shift();
+      storage.deletePackage(attachment, function () {
+        unlinkNext(cb);
+      });
+    };
+    unlinkNext(function () {
+      // try to unlink the directory, but ignore errors because it can fail
+      storage.removePackage(function (err) {
+        callback(err);
+      });
+    });
+  }
+
+  /**
+   * Ensure the dist file remains as the same protocol
+   * @param {Object} hash metadata
+   * @param {String} upLinkKey registry key
+   * @private
+   */
+  _updateUplinkToRemoteProtocol(hash, upLinkKey) {
+    // if we got this information from a known registry,
+    // use the same protocol for the tarball
+    //
+    // see https://github.com/rlidwka/sinopia/issues/166
+    const tarballUrl = _url.default.parse(hash.url);
+    const uplinkUrl = _url.default.parse(this.config.uplinks[upLinkKey].url);
+    if (uplinkUrl.host === tarballUrl.host) {
+      tarballUrl.protocol = uplinkUrl.protocol;
+      hash.registry = upLinkKey;
+      hash.url = _url.default.format(tarballUrl);
+    }
+  }
+  async getSecret(config) {
+    const secretKey = await this.storagePlugin.getSecret();
+    return this.storagePlugin.setSecret(config.checkSecretKey(secretKey));
+  }
+  saveToken(token) {
+    if (_lodash.default.isFunction(this.storagePlugin.saveToken) === false) {
+      return Promise.reject(_utils2.ErrorCode.getCode(_constants.HTTP_STATUS.SERVICE_UNAVAILABLE, _constants.SUPPORT_ERRORS.PLUGIN_MISSING_INTERFACE));
+    }
+    return this.storagePlugin.saveToken(token);
+  }
+  deleteToken(user, tokenKey) {
+    if (_lodash.default.isFunction(this.storagePlugin.deleteToken) === false) {
+      return Promise.reject(_utils2.ErrorCode.getCode(_constants.HTTP_STATUS.SERVICE_UNAVAILABLE, _constants.SUPPORT_ERRORS.PLUGIN_MISSING_INTERFACE));
+    }
+    return this.storagePlugin.deleteToken(user, tokenKey);
+  }
+  readTokens(filter) {
+    if (_lodash.default.isFunction(this.storagePlugin.readTokens) === false) {
+      return Promise.reject(_utils2.ErrorCode.getCode(_constants.HTTP_STATUS.SERVICE_UNAVAILABLE, _constants.SUPPORT_ERRORS.PLUGIN_MISSING_INTERFACE));
+    }
+    return this.storagePlugin.readTokens(filter);
+  }
+}
+var _default = exports.default = LocalStorage;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_assert","_interopRequireDefault","require","_debug","_lodash","_url","_streams","_utils","_constants","_storageUtils","_utils2","e","__esModule","default","debug","builDebug","LocalStorage","constructor","config","logger","localStorage","storagePlugin","addPackage","name","pkg","callback","storage","_getLocalStorage","_","isNil","ErrorCode","getNotFound","createPackage","generatePackageTemplate","err","isNull","code","STORAGE","FILE_EXIST_ERROR","HTTP_STATUS","CONFLICT","getConflict","latest","getLatestVersion","versions","removePackage","readPackage","data","NO_SUCH_FILE_ERROR","NOT_FOUND","normalizePackage","remove","removeFailed","error","getBadData","message","deletePackage","PACKAGE_FILE_NAME","attachments","Object","keys","_attachments","_deleteAttachments","updateVersions","packageInfo","_readCreatePackage","packageLocalJson","change","readme","getLatestReadme","versionId","version","cleanUpReadme","contributors","normalizeContributors","dist","tarball","urlObject","UrlNode","parse","filename","pathname","replace","_distfiles","hash","url","sha","shasum","upLink","Symbol","for","_updateUplinkToRemoteProtocol","tag","DIST_TAGS","up","_uplinks","prototype","hasOwnProperty","call","need_change","isObject","etag","fetched","isEqual","time","_writePackage","addVersion","metadata","_updatePackage","cb","hasVersion","isString","errorMessage","getBadRequest","currentDate","Date","toISOString","created","tagVersion","add","addFailed","mergeTags","pkgName","tags","_getVersionNotFound","API_ERROR","VERSION_NOT_EXIST","_getFileNotAvailable","changePackage","incomingPkg","revision","localData","incomingVersion","info","file","incomingDeprecated","deprecated","modified","USERS","removeTarball","assert","validateName","addTarball","length","shaOneHash","createTarballHash","uploadStream","UploadTarball","_transform","abort","done","args","update","appliedData","apply","process","nextTick","emit","getForbidden","writeStream","writeTarball","on","getPackageMetadata","_err","updater","digest","pipe","getTarball","_createFailureStreamResponse","_streamSuccessReadTarBall","stream","ReadTarball","readTarballStream","readTarball","e404","content","_readPackage","getPackageMetadataAsync","Promise","resolve","reject","updateVersionsAsync","result","search","startKey","options","objectMode","_searchEachPackage","item","parseInt","prepareSearchPackage","push","onEnd","end","getPackageStorage","_internalError","onPackage","warn","_createNewPackage","getInternalError","updateHandler","updatePackage","bind","json","savePackage","_setDefaultRevision","_rev","DEFAULT_REVISION","generateRevision","unlinkNext","isEmpty","attachment","shift","upLinkKey","tarballUrl","uplinkUrl","uplinks","host","protocol","registry","format","getSecret","secretKey","setSecret","checkSecretKey","saveToken","token","isFunction","getCode","SERVICE_UNAVAILABLE","SUPPORT_ERRORS","PLUGIN_MISSING_INTERFACE","deleteToken","user","tokenKey","readTokens","filter","_default","exports"],"sources":["../../src/lib/local-storage.ts"],"sourcesContent":["import assert from 'assert';\nimport builDebug from 'debug';\nimport _ from 'lodash';\nimport UrlNode from 'url';\n\nimport { ReadTarball, UploadTarball } from '@verdaccio/streams';\nimport {\n  Author,\n  Callback,\n  Config,\n  DistFile,\n  Logger,\n  Manifest,\n  MergeTags,\n  StorageUpdateCallback,\n  Token,\n  TokenFilter,\n  Version,\n  onEndSearchPackage,\n  onSearchPackage,\n} from '@verdaccio/types';\nimport {\n  createTarballHash,\n  getLatestVersion,\n  normalizeContributors,\n  validateName,\n} from '@verdaccio/utils';\n\nimport { StoragePluginLegacy } from '../../types/custom';\nimport { StringValue } from '../types';\nimport { API_ERROR, DIST_TAGS, HTTP_STATUS, STORAGE, SUPPORT_ERRORS, USERS } from './constants';\nimport {\n  cleanUpReadme,\n  generatePackageTemplate,\n  generateRevision,\n  getLatestReadme,\n  normalizePackage,\n} from './storage-utils';\nimport { prepareSearchPackage } from './storage-utils';\nimport { ErrorCode, isObject, tagVersion } from './utils';\n\nconst debug = builDebug('verdaccio:local-storage');\nexport type StoragePlugin = StoragePluginLegacy<Config> | any;\n/**\n * Implements Storage interface (same for storage.js, local-storage.js, up-storage.js).\n */\nclass LocalStorage {\n  public config: Config;\n  public storagePlugin: StoragePlugin;\n  public logger: Logger;\n\n  public constructor(config: Config, logger: Logger, localStorage: StoragePlugin) {\n    this.logger = logger;\n    this.config = config;\n    this.storagePlugin = localStorage;\n  }\n\n  public addPackage(name: string, pkg: Manifest, callback: Callback): void {\n    const storage: any = this._getLocalStorage(name);\n\n    if (_.isNil(storage)) {\n      return callback(ErrorCode.getNotFound('this package cannot be added'));\n    }\n\n    storage.createPackage(name, generatePackageTemplate(name), (err) => {\n      // FIXME: it will be fixed here https://github.com/verdaccio/verdaccio/pull/1360\n      // @ts-ignore\n      if (\n        _.isNull(err) === false &&\n        (err.code === STORAGE.FILE_EXIST_ERROR || err.code === HTTP_STATUS.CONFLICT)\n      ) {\n        return callback(ErrorCode.getConflict());\n      }\n\n      const latest = getLatestVersion(pkg);\n      if (_.isNil(latest) === false && pkg.versions[latest]) {\n        return callback(null, pkg.versions[latest]);\n      }\n\n      return callback();\n    });\n  }\n\n  /**\n   * Remove package.\n   * @param {*} name\n   * @param {*} callback\n   * @return {Function}\n   */\n  public removePackage(name: string, callback: Callback): void {\n    const storage: any = this._getLocalStorage(name);\n    debug('[storage] removing package %o', name);\n    if (_.isNil(storage)) {\n      return callback(ErrorCode.getNotFound());\n    }\n\n    storage.readPackage(name, (err, data: Manifest): void => {\n      if (_.isNil(err) === false) {\n        if (err.code === STORAGE.NO_SUCH_FILE_ERROR || err.code === HTTP_STATUS.NOT_FOUND) {\n          return callback(ErrorCode.getNotFound());\n        }\n        return callback(err);\n      }\n\n      data = normalizePackage(data);\n      this.storagePlugin.remove(name, (removeFailed: Error): void => {\n        if (removeFailed) {\n          // This will happen when database is locked\n          this.logger.error(\n            { name },\n            `[storage/removePackage] the database is locked, removed has failed for @{name}`\n          );\n          return callback(ErrorCode.getBadData(removeFailed.message));\n        }\n\n        storage.deletePackage(STORAGE.PACKAGE_FILE_NAME, (err): void => {\n          if (err) {\n            return callback(err);\n          }\n          const attachments = Object.keys(data._attachments);\n\n          this._deleteAttachments(storage, attachments, callback);\n        });\n      });\n    });\n  }\n\n  /**\n   * Synchronize remote package info with the local one\n   * @param {*} name\n   * @param {*} packageInfo\n   * @param {*} callback\n   */\n  public updateVersions(name: string, packageInfo: Manifest, callback: Callback): void {\n    this._readCreatePackage(name, (err, packageLocalJson): void => {\n      if (err) {\n        return callback(err);\n      }\n\n      let change = false;\n      // updating readme\n      packageLocalJson.readme = getLatestReadme(packageInfo);\n      if (packageInfo.readme !== packageLocalJson.readme) {\n        change = true;\n      }\n      for (const versionId in packageInfo.versions) {\n        if (_.isNil(packageLocalJson.versions[versionId])) {\n          let version = packageInfo.versions[versionId];\n\n          // we don't keep readme for package versions,\n          // only one readme per package\n          version = cleanUpReadme(version);\n          version.contributors = normalizeContributors(version.contributors as Author[]);\n\n          change = true;\n          packageLocalJson.versions[versionId] = version;\n\n          if (version.dist && version.dist.tarball) {\n            const urlObject: any = UrlNode.parse(version.dist.tarball);\n            const filename = urlObject.pathname.replace(/^.*\\//, '');\n\n            // we do NOT overwrite any existing records\n            if (_.isNil(packageLocalJson._distfiles[filename])) {\n              const hash: DistFile = (packageLocalJson._distfiles[filename] = {\n                url: version.dist.tarball,\n                sha: version.dist.shasum,\n              });\n              /* eslint spaced-comment: 0 */\n              const upLink: string = version[Symbol.for('__verdaccio_uplink')];\n\n              if (_.isNil(upLink) === false) {\n                this._updateUplinkToRemoteProtocol(hash, upLink);\n              }\n            }\n          }\n        }\n      }\n\n      for (const tag in packageInfo[DIST_TAGS]) {\n        if (\n          !packageLocalJson[DIST_TAGS][tag] ||\n          packageLocalJson[DIST_TAGS][tag] !== packageInfo[DIST_TAGS][tag]\n        ) {\n          change = true;\n          packageLocalJson[DIST_TAGS][tag] = packageInfo[DIST_TAGS][tag];\n        }\n      }\n\n      for (const up in packageInfo._uplinks) {\n        if (Object.prototype.hasOwnProperty.call(packageInfo._uplinks, up)) {\n          const need_change =\n            !isObject(packageLocalJson._uplinks[up]) ||\n            packageInfo._uplinks[up].etag !== packageLocalJson._uplinks[up].etag ||\n            packageInfo._uplinks[up].fetched !== packageLocalJson._uplinks[up].fetched;\n\n          if (need_change) {\n            change = true;\n            packageLocalJson._uplinks[up] = packageInfo._uplinks[up];\n          }\n        }\n      }\n\n      if ('time' in packageInfo && !_.isEqual(packageLocalJson.time, packageInfo.time)) {\n        packageLocalJson.time = packageInfo.time;\n        change = true;\n      }\n\n      if (change) {\n        debug('updating package %o info', name);\n        this._writePackage(name, packageLocalJson, function (err): void {\n          callback(err, packageLocalJson);\n        });\n      } else {\n        callback(null, packageLocalJson);\n      }\n    });\n  }\n\n  /**\n   * Add a new version to a previous local package.\n   * @param {*} name\n   * @param {*} version\n   * @param {*} metadata\n   * @param {*} tag\n   * @param {*} callback\n   */\n  public addVersion(\n    name: string,\n    version: string,\n    metadata: Version,\n    tag: StringValue,\n    callback: Callback\n  ): void {\n    this._updatePackage(\n      name,\n      (data, cb: Callback): void => {\n        // keep only one readme per package\n        data.readme = metadata.readme;\n\n        // TODO: lodash remove\n        metadata = cleanUpReadme(metadata);\n        metadata.contributors = normalizeContributors(metadata.contributors as Author[]);\n\n        const hasVersion = data.versions[version] != null;\n        if (hasVersion) {\n          return cb(ErrorCode.getConflict());\n        }\n\n        // if uploaded tarball has a different shasum, it's very likely that we have some kind of error\n        if (isObject(metadata.dist) && _.isString(metadata.dist.tarball)) {\n          const tarball = metadata.dist.tarball.replace(/.*\\//, '');\n\n          if (isObject(data._attachments[tarball])) {\n            if (\n              _.isNil(data._attachments[tarball].shasum) === false &&\n              _.isNil(metadata.dist.shasum) === false\n            ) {\n              if (data._attachments[tarball].shasum != metadata.dist.shasum) {\n                const errorMessage = `shasum error, ${data._attachments[tarball].shasum} != ${metadata.dist.shasum}`;\n                return cb(ErrorCode.getBadRequest(errorMessage));\n              }\n            }\n\n            const currentDate = new Date().toISOString();\n\n            // some old storage do not have this field #740\n            if (_.isNil(data.time)) {\n              data.time = {};\n            }\n\n            data.time['modified'] = currentDate;\n\n            if ('created' in data.time === false) {\n              data.time.created = currentDate;\n            }\n\n            data.time[version] = currentDate;\n            data._attachments[tarball].version = version;\n          }\n        }\n\n        data.versions[version] = metadata;\n        tagVersion(data, version, tag);\n\n        this.storagePlugin.add(name, (addFailed): void => {\n          if (addFailed) {\n            return cb(ErrorCode.getBadData(addFailed.message));\n          }\n\n          cb();\n        });\n      },\n      callback\n    );\n  }\n\n  /**\n   * Merge a new list of tags for a local packages with the existing one.\n   * @param {*} pkgName\n   * @param {*} tags\n   * @param {*} callback\n   */\n  public mergeTags(pkgName: string, tags: MergeTags, callback: Callback): void {\n    this._updatePackage(\n      pkgName,\n      (data, cb): void => {\n        /* eslint guard-for-in: 0 */\n        for (const tag in tags) {\n          // this handle dist-tag rm command\n          if (_.isNull(tags[tag])) {\n            delete data[DIST_TAGS][tag];\n            continue;\n          }\n\n          if (_.isNil(data.versions[tags[tag]])) {\n            return cb(this._getVersionNotFound());\n          }\n          const version: string = tags[tag];\n          tagVersion(data, version, tag);\n        }\n        cb(null);\n      },\n      callback\n    );\n  }\n\n  /**\n   * Return version not found\n   * @return {String}\n   * @private\n   */\n  private _getVersionNotFound(): any {\n    return ErrorCode.getNotFound(API_ERROR.VERSION_NOT_EXIST);\n  }\n\n  /**\n   * Return file no available\n   * @return {String}\n   * @private\n   */\n  private _getFileNotAvailable(): any {\n    return ErrorCode.getNotFound('no such file available');\n  }\n\n  /**\n   * Update the package metadata, tags and attachments (tarballs).\n   * Note: Currently supports unpublishing and deprecation.\n   * @param {*} name\n   * @param {*} incomingPkg\n   * @param {*} revision\n   * @param {*} callback\n   * @return {Function}\n   */\n  public changePackage(\n    name: string,\n    incomingPkg: Manifest,\n    revision: string | void,\n    callback: Callback\n  ): void {\n    if (!isObject(incomingPkg.versions) || !isObject(incomingPkg[DIST_TAGS])) {\n      this.logger.error({ name }, `changePackage bad data for @{name}`);\n      return callback(ErrorCode.getBadData());\n    }\n    debug('changePackage udapting package for %o', name);\n    this._updatePackage(\n      name,\n      (localData: Manifest, cb: Callback): void => {\n        for (const version in localData.versions) {\n          const incomingVersion = incomingPkg.versions[version];\n          if (_.isNil(incomingVersion)) {\n            this.logger.info({ name: name, version: version }, 'unpublishing @{name}@@{version}');\n\n            // FIXME: I prefer return a new object rather mutate the metadata\n            delete localData.versions[version];\n            delete localData.time![version];\n\n            for (const file in localData._attachments) {\n              if (localData._attachments[file].version === version) {\n                delete localData._attachments[file].version;\n              }\n            }\n          } else if (Object.prototype.hasOwnProperty.call(incomingVersion, 'deprecated')) {\n            const incomingDeprecated = incomingVersion.deprecated;\n            if (incomingDeprecated != localData.versions[version].deprecated) {\n              if (!incomingDeprecated) {\n                this.logger.info(\n                  { name: name, version: version },\n                  'undeprecating @{name}@@{version}'\n                );\n                delete localData.versions[version].deprecated;\n              } else {\n                this.logger.info(\n                  { name: name, version: version },\n                  'deprecating @{name}@@{version}'\n                );\n                localData.versions[version].deprecated = incomingDeprecated;\n              }\n              localData.time!.modified = new Date().toISOString();\n            }\n          }\n        }\n\n        localData[USERS] = incomingPkg[USERS];\n        localData[DIST_TAGS] = incomingPkg[DIST_TAGS];\n        cb(null);\n      },\n      function (err): void {\n        if (err) {\n          return callback(err);\n        }\n        callback();\n      }\n    );\n  }\n  /**\n   * Remove a tarball.\n   * @param {*} name\n   * @param {*} filename\n   * @param {*} revision\n   * @param {*} callback\n   */\n  public removeTarball(name: string, filename: string, revision: string, callback: Callback): void {\n    assert(validateName(filename));\n\n    this._updatePackage(\n      name,\n      (data, cb): void => {\n        if (data._attachments[filename]) {\n          delete data._attachments[filename];\n          cb(null);\n        } else {\n          cb(this._getFileNotAvailable());\n        }\n      },\n      (err: any): void => {\n        if (err) {\n          return callback(err);\n        }\n        const storage = this._getLocalStorage(name);\n\n        if (storage) {\n          storage.deletePackage(filename, callback);\n        }\n      }\n    );\n  }\n\n  /**\n   * Add a tarball.\n   * @param {String} name\n   * @param {String} filename\n   * @return {Stream}\n   */\n  public addTarball(name: string, filename: string) {\n    assert(validateName(filename));\n\n    let length = 0;\n    const shaOneHash = createTarballHash();\n    const uploadStream = new UploadTarball({});\n    const _transform = uploadStream._transform;\n    const storage = this._getLocalStorage(name);\n\n    uploadStream.abort = function (): void {};\n    uploadStream.done = function (): void {};\n\n    uploadStream._transform = function (data, ...args): void {\n      shaOneHash.update(data);\n      // measure the length for validation reasons\n      length += data.length;\n      const appliedData = [data, ...args];\n      // FIXME: not sure about this approach, tsc complains\n      // @ts-ignore\n      _transform.apply(uploadStream, appliedData);\n    };\n\n    if (name === '__proto__') {\n      process.nextTick((): void => {\n        uploadStream.emit('error', ErrorCode.getForbidden());\n      });\n      return uploadStream;\n    }\n\n    if (!storage) {\n      process.nextTick((): void => {\n        uploadStream.emit('error', \"can't upload this package\");\n      });\n      return uploadStream;\n    }\n\n    const writeStream = storage.writeTarball(filename);\n\n    writeStream.on('error', (err) => {\n      if (err.code === STORAGE.FILE_EXIST_ERROR || err.code === HTTP_STATUS.CONFLICT) {\n        uploadStream.emit('error', ErrorCode.getConflict());\n        uploadStream.abort();\n      } else if (err.code === STORAGE.NO_SUCH_FILE_ERROR || err.code === HTTP_STATUS.NOT_FOUND) {\n        // check if package exists to throw an appropriate message\n        this.getPackageMetadata(name, function (_err: any): void {\n          if (_err) {\n            uploadStream.emit('error', _err);\n          } else {\n            uploadStream.emit('error', err);\n          }\n        });\n      } else {\n        uploadStream.emit('error', err);\n      }\n    });\n\n    writeStream.on('open', function (): void {\n      // re-emitting open because it's handled in storage.js\n      uploadStream.emit('open');\n    });\n\n    writeStream.on('success', (): void => {\n      this._updatePackage(\n        name,\n        function updater(data, cb): void {\n          data._attachments[filename] = {\n            shasum: shaOneHash.digest('hex'),\n          };\n          cb(null);\n        },\n        function (err): void {\n          if (err) {\n            uploadStream.emit('error', err);\n          } else {\n            uploadStream.emit('success');\n          }\n        }\n      );\n    });\n\n    uploadStream.abort = function (): void {\n      writeStream.abort();\n    };\n\n    uploadStream.done = function (): void {\n      if (!length) {\n        uploadStream.emit('error', ErrorCode.getBadData('refusing to accept zero-length file'));\n        writeStream.abort();\n      } else {\n        writeStream.done();\n      }\n    };\n\n    uploadStream.pipe(writeStream);\n\n    return uploadStream;\n  }\n\n  /**\n   * Get a tarball.\n   * @param {*} name\n   * @param {*} filename\n   * @return {ReadTarball}\n   */\n  public getTarball(name: string, filename: string) {\n    assert(validateName(filename));\n\n    const storage = this._getLocalStorage(name);\n\n    if (_.isNil(storage)) {\n      return this._createFailureStreamResponse();\n    }\n\n    return this._streamSuccessReadTarBall(storage, filename);\n  }\n\n  /**\n   * Return a stream that emits a read failure.\n   * @private\n   * @return {ReadTarball}\n   */\n  private _createFailureStreamResponse() {\n    const stream = new ReadTarball({});\n\n    process.nextTick((): void => {\n      stream.emit('error', this._getFileNotAvailable());\n    });\n    return stream;\n  }\n\n  /**\n   * Return a stream that emits the tarball data\n   * @param {Object} storage\n   * @param {String} filename\n   * @private\n   * @return {ReadTarball}\n   */\n  private _streamSuccessReadTarBall(storage: any, filename: string) {\n    const stream = new ReadTarball({});\n    const readTarballStream = storage.readTarball(filename);\n    const e404 = ErrorCode.getNotFound;\n\n    stream.abort = function (): void {\n      if (_.isNil(readTarballStream) === false) {\n        readTarballStream.abort();\n      }\n    };\n\n    readTarballStream.on('error', function (err) {\n      if (err.code === STORAGE.NO_SUCH_FILE_ERROR || err.code === HTTP_STATUS.NOT_FOUND) {\n        stream.emit('error', e404('no such file available'));\n      } else {\n        stream.emit('error', err);\n      }\n    });\n\n    readTarballStream.on('content-length', function (content): void {\n      stream.emit('content-length', content);\n    });\n\n    readTarballStream.on('open', function (): void {\n      // re-emitting open because it's handled in storage.js\n      stream.emit('open');\n      readTarballStream.pipe(stream);\n    });\n\n    return stream;\n  }\n\n  /**\n   * Retrieve a package by name.\n   * @param {*} name\n   * @param {*} callback\n   * @return {Function}\n   */\n  public getPackageMetadata(name: string, callback: Callback = (): void => {}): void {\n    const storage = this._getLocalStorage(name);\n    if (_.isNil(storage)) {\n      return callback(ErrorCode.getNotFound());\n    }\n\n    this._readPackage(name, storage, callback);\n  }\n\n  public getPackageMetadataAsync(name: string): Promise<Manifest> {\n    return new Promise<Manifest>((resolve, reject) => {\n      this.getPackageMetadata(name, (err: any, metadata: Manifest) => {\n        if (err) {\n          return reject(err);\n        }\n        resolve(metadata);\n      });\n    });\n  }\n\n  public updateVersionsAsync(name: string, packageInfo: Manifest): Promise<Manifest> {\n    return new Promise<Manifest>((resolve, reject) => {\n      this.updateVersions(name, packageInfo, (err: any, result: Manifest) => {\n        if (err) {\n          return reject(err);\n        }\n        resolve(result);\n      });\n    });\n  }\n\n  /**\n   * Search a local package.\n   * @param {*} startKey\n   * @param {*} options\n   * @return {Function}\n   */\n  public search(startKey: string, options: any) {\n    debug('options for search %o', options);\n    const stream = new ReadTarball({ objectMode: true });\n\n    this._searchEachPackage(\n      (item: Manifest, cb: Callback): void => {\n        // @ts-ignore\n        if (item.time > parseInt(startKey, 10)) {\n          this.getPackageMetadata(item.name, (err: any, data: Manifest): void => {\n            if (err) {\n              return cb(err);\n            }\n\n            // @ts-ignore\n            const time = new Date(item.time).toISOString();\n            const result = prepareSearchPackage(data, time);\n            if (_.isNil(result) === false) {\n              stream.push(result);\n            }\n            cb(null);\n          });\n        } else {\n          cb(null);\n        }\n      },\n      function onEnd(err): void {\n        if (err) {\n          stream.emit('error', err);\n          return;\n        }\n        stream.end();\n      }\n    );\n\n    return stream;\n  }\n\n  /**\n   * Retrieve a wrapper that provide access to the package location.\n   * @param {Object} pkgName package name.\n   * @return {Object}\n   */\n  private _getLocalStorage(pkgName: string) {\n    return this.storagePlugin.getPackageStorage(pkgName);\n  }\n\n  /**\n   * Read a json file from storage.\n   * @param {Object} storage\n   * @param {Function} callback\n   */\n  private _readPackage(name: string, storage: any, callback: Callback): void {\n    storage.readPackage(name, (err, result): void => {\n      if (err) {\n        if (err.code === STORAGE.NO_SUCH_FILE_ERROR || err.code === HTTP_STATUS.NOT_FOUND) {\n          return callback(ErrorCode.getNotFound());\n        }\n        return callback(this._internalError(err, STORAGE.PACKAGE_FILE_NAME, 'error reading'));\n      }\n\n      callback(err, normalizePackage(result));\n    });\n  }\n\n  /**\n   * Walks through each package and calls `on_package` on them.\n   * @param {*} onPackage\n   * @param {*} onEnd\n   */\n  private _searchEachPackage(onPackage: onSearchPackage, onEnd: onEndSearchPackage): void {\n    // save wait whether plugin still do not support search functionality\n    if (_.isNil(this.storagePlugin.search)) {\n      this.logger.warn('plugin search not implemented yet');\n      onEnd();\n    } else {\n      this.storagePlugin.search(onPackage, onEnd, validateName);\n    }\n  }\n\n  /**\n   * Retrieve either a previous created local package or a boilerplate.\n   * @param {*} pkgName\n   * @param {*} callback\n   * @return {Function}\n   */\n  private _readCreatePackage(pkgName: string, callback: Callback): void {\n    const storage: any = this._getLocalStorage(pkgName);\n    if (_.isNil(storage)) {\n      this._createNewPackage(pkgName, callback);\n      return;\n    }\n\n    storage.readPackage(pkgName, (err, data): void => {\n      // TODO: race condition\n      if (_.isNil(err) === false) {\n        if (err.code === STORAGE.NO_SUCH_FILE_ERROR || err.code === HTTP_STATUS.NOT_FOUND) {\n          data = generatePackageTemplate(pkgName);\n        } else {\n          return callback(this._internalError(err, STORAGE.PACKAGE_FILE_NAME, 'error reading'));\n        }\n      }\n\n      callback(null, normalizePackage(data));\n    });\n  }\n\n  private _createNewPackage(name: string, callback: Callback): Callback {\n    return callback(null, normalizePackage(generatePackageTemplate(name)));\n  }\n\n  /**\n   * Handle internal error\n   * @param {*} err\n   * @param {*} file\n   * @param {*} message\n   * @return {Object} Error instance\n   */\n  private _internalError(err: string, file: string, message: string): any {\n    this.logger.error({ err: err, file: file }, `${message}  @{file}: @{!err.message}`);\n\n    return ErrorCode.getInternalError();\n  }\n\n  /**\n   * @param {*} name package name\n   * @param {*} updateHandler function(package, cb) - update function\n   * @param {*} callback callback that gets invoked after it's all updated\n   * @return {Function}\n   */\n  private _updatePackage(\n    name: string,\n    updateHandler: StorageUpdateCallback,\n    callback: Callback\n  ): void {\n    const storage = this._getLocalStorage(name);\n\n    if (!storage) {\n      return callback(ErrorCode.getNotFound());\n    }\n\n    storage.updatePackage(\n      name,\n      updateHandler,\n      this._writePackage.bind(this),\n      normalizePackage,\n      callback\n    );\n  }\n\n  /**\n   * Update the revision (_rev) string for a package.\n   * @param {*} name\n   * @param {*} json\n   * @param {*} callback\n   * @return {Function}\n   */\n  private _writePackage(name: string, json: Manifest, callback: Callback): void {\n    const storage: any = this._getLocalStorage(name);\n    if (_.isNil(storage)) {\n      return callback();\n    }\n    storage.savePackage(name, this._setDefaultRevision(json), callback);\n  }\n\n  private _setDefaultRevision(json: Manifest): Manifest {\n    // calculate revision from couch db\n    if (_.isString(json._rev) === false) {\n      json._rev = STORAGE.DEFAULT_REVISION;\n    }\n\n    // this is intended in debug mode we do not want modify the store revision\n    if (_.isNil(this.config._debug)) {\n      json._rev = generateRevision(json._rev);\n    }\n\n    return json;\n  }\n\n  private _deleteAttachments(storage: any, attachments: string[], callback: Callback): void {\n    debug('[storage/_deleteAttachments] delete attachments total: %o', attachments?.length);\n    const unlinkNext = function (cb): void {\n      if (_.isEmpty(attachments)) {\n        return cb();\n      }\n\n      const attachment = attachments.shift();\n      storage.deletePackage(attachment, function (): void {\n        unlinkNext(cb);\n      });\n    };\n\n    unlinkNext(function (): void {\n      // try to unlink the directory, but ignore errors because it can fail\n      storage.removePackage(function (err): void {\n        callback(err);\n      });\n    });\n  }\n\n  /**\n   * Ensure the dist file remains as the same protocol\n   * @param {Object} hash metadata\n   * @param {String} upLinkKey registry key\n   * @private\n   */\n  private _updateUplinkToRemoteProtocol(hash: DistFile, upLinkKey: string): void {\n    // if we got this information from a known registry,\n    // use the same protocol for the tarball\n    //\n    // see https://github.com/rlidwka/sinopia/issues/166\n    const tarballUrl: any = UrlNode.parse(hash.url);\n    const uplinkUrl: any = UrlNode.parse(this.config.uplinks[upLinkKey].url);\n\n    if (uplinkUrl.host === tarballUrl.host) {\n      tarballUrl.protocol = uplinkUrl.protocol;\n      hash.registry = upLinkKey;\n      hash.url = UrlNode.format(tarballUrl);\n    }\n  }\n\n  public async getSecret(config: Config): Promise<string> {\n    const secretKey = await this.storagePlugin.getSecret();\n\n    return this.storagePlugin.setSecret(config.checkSecretKey(secretKey));\n  }\n\n  public saveToken(token: Token): Promise<any> {\n    if (_.isFunction(this.storagePlugin.saveToken) === false) {\n      return Promise.reject(\n        ErrorCode.getCode(HTTP_STATUS.SERVICE_UNAVAILABLE, SUPPORT_ERRORS.PLUGIN_MISSING_INTERFACE)\n      );\n    }\n\n    return this.storagePlugin.saveToken(token);\n  }\n\n  public deleteToken(user: string, tokenKey: string): Promise<any> {\n    if (_.isFunction(this.storagePlugin.deleteToken) === false) {\n      return Promise.reject(\n        ErrorCode.getCode(HTTP_STATUS.SERVICE_UNAVAILABLE, SUPPORT_ERRORS.PLUGIN_MISSING_INTERFACE)\n      );\n    }\n\n    return this.storagePlugin.deleteToken(user, tokenKey);\n  }\n\n  public readTokens(filter: TokenFilter): Promise<Token[]> {\n    if (_.isFunction(this.storagePlugin.readTokens) === false) {\n      return Promise.reject(\n        ErrorCode.getCode(HTTP_STATUS.SERVICE_UNAVAILABLE, SUPPORT_ERRORS.PLUGIN_MISSING_INTERFACE)\n      );\n    }\n\n    return this.storagePlugin.readTokens(filter);\n  }\n}\n\nexport default LocalStorage;\n"],"mappings":"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","ignoreList":[]}