verdaccio
Version:
A lightweight private npm proxy registry
760 lines (730 loc) • 98 kB
JavaScript
"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