@verdaccio/canary 6.3.2-canary.404363f

package/build/api/endpoint/api/publish.js

@@ -0,0 +1,359 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addVersion = addVersion;
+exports.default = publish;
+exports.publishPackage = publishPackage;
+exports.removeTarball = removeTarball;
+exports.unPublishPackage = unPublishPackage;
+exports.uploadPackageTarball = uploadPackageTarball;
+var _debug = _interopRequireDefault(require("debug"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _mime = _interopRequireDefault(require("mime"));
+var _path = _interopRequireDefault(require("path"));
+var _core = require("@verdaccio/core");
+var _hooks = require("@verdaccio/hooks");
+var _middleware = require("@verdaccio/middleware");
+var _constants = require("../../../lib/constants");
+var _logger = require("../../../lib/logger");
+var _storageUtils = require("../../../lib/storage-utils");
+var _utils = require("../../../lib/utils");
+var _star = _interopRequireDefault(require("./star"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const debug = (0, _debug.default)('verdaccio:publish');
+function publish(router, auth, storage, config) {
+  const can = (0, _middleware.allow)(auth, {
+    beforeAll: (params, message) => _logger.logger.trace(params, message),
+    afterAll: (params, message) => _logger.logger.trace(params, message)
+  });
+
+  /**
+   * Publish a package / update package / un/start a package
+   *
+   * There are multiples scenarios here to be considered:
+   *
+   * 1. Publish scenario
+   *
+   * Publish a package consist of at least 1 step (PUT) with a metadata payload.
+   * When a package is published, an _attachment property is present that contains the data
+   * of the tarball.
+   *
+   * Example flow of publish.
+   *
+   *  npm http fetch PUT 201 http://localhost:4873/@scope%2ftest1 9627ms
+      npm info lifecycle @scope/test1@1.0.1~publish: @scope/test1@1.0.1
+      npm info lifecycle @scope/test1@1.0.1~postpublish: @scope/test1@1.0.1
+      + @scope/test1@1.0.1
+      npm verb exit [ 0, true ]
+   *
+   *
+   * 2. Unpublish scenario
+   *
+   * Unpublish consist in 3 steps.
+   *  1. Try to fetch  metadata -> if it fails, return 404
+   *  2. Compute metadata locally (client side) and send a mutate payload excluding the version to be unpublished
+   *    eg: if metadata reflects 1.0.1, 1.0.2 and 1.0.3, the computed metadata won't include 1.0.3.
+   *  3. Once the second step has been successfully finished, delete the tarball.
+   *
+   *  All these steps are consecutive and required, there is no transacions here, if step 3 fails, metadata might
+   *  get corrupted.
+   *
+   *  Note the unpublish call will suffix in the url a /-rev/14-5d500cfce92f90fd revision number, this not
+   *  used internally.
+   *
+   *
+   * Example flow of unpublish.
+   *
+   * npm http fetch GET 200 http://localhost:4873/@scope%2ftest1?write=true 1680ms
+     npm http fetch PUT 201 http://localhost:4873/@scope%2ftest1/-rev/14-5d500cfce92f90fd 956606ms attempt #2
+     npm http fetch GET 200 http://localhost:4873/@scope%2ftest1?write=true 1601ms
+     npm http fetch DELETE 201 http://localhost:4873/@scope%2ftest1/-/test1-1.0.3.tgz/-rev/16-e11c8db282b2d992 19ms
+   *
+   * 3. Star a package
+   *
+   * Permissions: start a package depends of the publish and unpublish permissions, there is no specific flag for star or un start.
+   * The URL for star is similar to the unpublish (change package format)
+   *
+   * npm has no enpoint for star a package, rather mutate the metadata and acts as, the difference is the
+   * users property which is part of the payload and the body only includes
+   *
+   * {
+    "_id": pkgName,
+   	"_rev": "3-b0cdaefc9bdb77c8",
+    "users": {
+      [username]: boolean value (true, false)
+    }
+  }
+   *
+   */
+  router.put('/:package/:_rev?/:revision?', can('publish'), (0, _middleware.media)(_mime.default.getType('json')), _middleware.expectJson, publishPackage(storage, config, auth));
+
+  /**
+   * Un-publishing an entire package.
+   *
+   * This scenario happens when the first call detect there is only one version remaining
+   * in the metadata, then the client decides to DELETE the resource
+   * npm http fetch GET 304 http://localhost:4873/@scope%2ftest1?write=true 1076ms (from cache)
+     npm http fetch DELETE 201 http://localhost:4873/@scope%2ftest1/-rev/18-d8ebe3020bd4ac9c 22ms
+   */
+  router.delete('/:package/-rev/*', can('unpublish'), unPublishPackage(storage));
+
+  // removing a tarball
+  router.delete('/:package/-/:filename/-rev/:revision', can('unpublish'), can('publish'), removeTarball(storage));
+
+  // uploading package tarball
+  router.put('/:package/-/:filename/*', can('publish'), (0, _middleware.media)(_constants.HEADERS.OCTET_STREAM), uploadPackageTarball(storage));
+
+  // only used for development
+  if (config._debug) {
+    // adding a version
+    router.put('/:package/:version/-tag/:tag', can('publish'), (0, _middleware.media)(_mime.default.getType('json')), _middleware.expectJson, addVersion(storage));
+  }
+}
+
+/**
+ * Publish a package
+ */
+function publishPackage(storage, config, auth) {
+  const starApi = (0, _star.default)(storage);
+  return function (req, res, next) {
+    const packageName = req.params.package;
+    debug('publishing or updating a new version for %o', packageName);
+    /**
+     * Write tarball of stream data from package clients.
+     */
+    const createTarball = function (filename, data, cb) {
+      const stream = storage.addTarball(packageName, filename);
+      stream.on('error', function (err) {
+        cb(err);
+      });
+      stream.on('success', function () {
+        cb();
+      });
+      // this is dumb and memory-consuming, but what choices do we have?
+      // flow: we need first refactor this file before decides which type use here
+      stream.end(Buffer.from(data.data, 'base64'));
+      stream.done();
+    };
+
+    /**
+     * Add new package version in storage
+     */
+    const createVersion = function (version, metadata, cb) {
+      storage.addVersion(packageName, version, metadata, null, cb);
+    };
+
+    /**
+     * Add new tags in storage
+     */
+    const addTags = function (tags, cb) {
+      storage.mergeTags(packageName, tags, cb);
+    };
+    const afterChange = function (error, okMessage, metadata) {
+      const metadataCopy = {
+        ...metadata
+      };
+      const {
+        _attachments,
+        versions
+      } = metadataCopy;
+
+      // `npm star` wouldn't have attachments
+      // and `npm deprecate` would have attachments as a empty object, i.e {}
+      if (_lodash.default.isNil(_attachments) || JSON.stringify(_attachments) === '{}') {
+        if (error) {
+          return next(error);
+        }
+        res.status(_constants.HTTP_STATUS.CREATED);
+        return next({
+          ok: okMessage,
+          success: true
+        });
+      }
+
+      // npm-registry-client 0.3+ embeds tarball into the json upload
+      // https://github.com/isaacs/npm-registry-client/commit/e9fbeb8b67f249394f735c74ef11fe4720d46ca0
+      // issue https://github.com/rlidwka/sinopia/issues/31, dealing with it here:
+      const isInvalidBodyFormat = (0, _utils.isObject)(_attachments) === false || (0, _utils.hasDiffOneKey)(_attachments) || (0, _utils.isObject)(versions) === false || (0, _utils.hasDiffOneKey)(versions);
+      if (isInvalidBodyFormat) {
+        // npm is doing something strange again
+        // if this happens in normal circumstances, report it as a bug
+        _logger.logger.info({
+          packageName
+        }, `wrong package format on publish a package @{packageName}`);
+        return next(_utils.ErrorCode.getBadRequest(_constants.API_ERROR.UNSUPORTED_REGISTRY_CALL));
+      }
+      if (error && error.status !== _constants.HTTP_STATUS.CONFLICT) {
+        return next(error);
+      }
+
+      // at this point document is either created or existed before
+      const [firstAttachmentKey] = Object.keys(_attachments);
+      createTarball(_path.default.basename(firstAttachmentKey), _attachments[firstAttachmentKey], function (error) {
+        if (error) {
+          return next(error);
+        }
+        const versionToPublish = Object.keys(versions)[0];
+        const versionMetadataToPublish = versions[versionToPublish];
+        versionMetadataToPublish.readme = _lodash.default.isNil(versionMetadataToPublish.readme) === false ? String(versionMetadataToPublish.readme) : '';
+        createVersion(versionToPublish, versionMetadataToPublish, function (error) {
+          if (error) {
+            return next(error);
+          }
+          addTags(metadataCopy[_constants.DIST_TAGS], async function (error) {
+            if (error) {
+              return next(error);
+            }
+            try {
+              await (0, _hooks.notify)(metadataCopy, config, req.remote_user, `${metadataCopy.name}@${versionToPublish}`);
+            } catch (error) {
+              _logger.logger.error({
+                error
+              }, 'notify batch service has failed: @{error}');
+            }
+            res.status(_constants.HTTP_STATUS.CREATED);
+            return next({
+              ok: okMessage,
+              success: true
+            });
+          });
+        });
+      });
+    };
+    if ((0, _storageUtils.isPublishablePackage)(req.body) === false && (0, _utils.isObject)(req.body.users)) {
+      return starApi(req, res, next);
+    }
+    try {
+      const metadata = _core.validationUtils.normalizeMetadata(req.body, packageName);
+      // check _attachments to distinguish publish and deprecate
+      if (req.params._rev || (0, _utils.isRelatedToDeprecation)(req.body) && _lodash.default.isEmpty(req.body._attachments)) {
+        debug('updating a new version for %o', packageName);
+        // we check unpublish permissions, an update is basically remove versions
+        const remote = req.remote_user;
+        auth.allow_unpublish({
+          packageName
+        }, remote, error => {
+          if (error) {
+            _logger.logger.error({
+              packageName
+            }, `not allowed to unpublish a version for @{packageName}`);
+            return next(error);
+          }
+          storage.changePackage(packageName, metadata, req.params.revision, function (error) {
+            afterChange(error, _constants.API_MESSAGE.PKG_CHANGED, metadata);
+          });
+        });
+      } else {
+        debug('adding a new version for %o', packageName);
+        storage.addPackage(packageName, metadata, function (error) {
+          afterChange(error, _constants.API_MESSAGE.PKG_CREATED, metadata);
+        });
+      }
+    } catch (error) {
+      debug('error on publish: %s', error.message);
+      _logger.logger.error({
+        packageName
+      }, 'error on publish, bad package data for @{packageName}');
+      return next(_utils.ErrorCode.getBadData(_constants.API_ERROR.BAD_PACKAGE_DATA));
+    }
+  };
+}
+
+/**
+ * un-publish a package
+ */
+function unPublishPackage(storage) {
+  return function (req, res, next) {
+    const packageName = req.params.package;
+    debug('unpublishing %o', packageName);
+    storage.removePackage(packageName, function (err) {
+      if (err) {
+        return next(err);
+      }
+      res.status(_constants.HTTP_STATUS.CREATED);
+      return next({
+        ok: _constants.API_MESSAGE.PKG_REMOVED
+      });
+    });
+  };
+}
+
+/**
+ * Delete tarball
+ */
+function removeTarball(storage) {
+  return function (req, res, next) {
+    const packageName = req.params.package;
+    const {
+      filename,
+      revision
+    } = req.params;
+    debug('removing a tarball for %o-%o-%o', packageName, filename, revision);
+    storage.removeTarball(packageName, filename, revision, function (err) {
+      if (err) {
+        return next(err);
+      }
+      res.status(_constants.HTTP_STATUS.CREATED);
+      debug('success remove tarball for %o-%o-%o', packageName, filename, revision);
+      return next({
+        ok: _constants.API_MESSAGE.TARBALL_REMOVED
+      });
+    });
+  };
+}
+/**
+ * Adds a new version
+ */
+function addVersion(storage) {
+  return function (req, res, next) {
+    const {
+      version,
+      tag
+    } = req.params;
+    const packageName = req.params.package;
+    storage.addVersion(packageName, version, req.body, tag, function (error) {
+      if (error) {
+        return next(error);
+      }
+      res.status(_constants.HTTP_STATUS.CREATED);
+      return next({
+        ok: _constants.API_MESSAGE.PKG_PUBLISHED
+      });
+    });
+  };
+}
+
+/**
+ * uploadPackageTarball
+ */
+function uploadPackageTarball(storage) {
+  return function (req, res, next) {
+    const packageName = req.params.package;
+    const stream = storage.addTarball(packageName, req.params.filename);
+    req.pipe(stream);
+
+    // checking if end event came before closing
+    let complete = false;
+    req.on('end', function () {
+      complete = true;
+      stream.done();
+    });
+    req.on('close', function () {
+      if (!complete) {
+        stream.abort();
+      }
+    });
+    stream.on('error', function (err) {
+      return res.locals.report_error(err);
+    });
+    stream.on('success', function () {
+      res.status(_constants.HTTP_STATUS.CREATED);
+      return next({
+        ok: _constants.API_MESSAGE.TARBALL_UPLOADED
+      });
+    });
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_debug","_interopRequireDefault","require","_lodash","_mime","_path","_core","_hooks","_middleware","_constants","_logger","_storageUtils","_utils","_star","e","__esModule","default","debug","buildDebug","publish","router","auth","storage","config","can","allow","beforeAll","params","message","logger","trace","afterAll","put","media","mime","getType","expectJson","publishPackage","delete","unPublishPackage","removeTarball","HEADERS","OCTET_STREAM","uploadPackageTarball","addVersion","starApi","star","req","res","next","packageName","package","createTarball","filename","data","cb","stream","addTarball","on","err","end","Buffer","from","done","createVersion","version","metadata","addTags","tags","mergeTags","afterChange","error","okMessage","metadataCopy","_attachments","versions","_","isNil","JSON","stringify","status","HTTP_STATUS","CREATED","ok","success","isInvalidBodyFormat","isObject","hasDiffOneKey","info","ErrorCode","getBadRequest","API_ERROR","UNSUPORTED_REGISTRY_CALL","CONFLICT","firstAttachmentKey","Object","keys","Path","basename","versionToPublish","versionMetadataToPublish","readme","String","DIST_TAGS","notify","remote_user","name","isPublishablePackage","body","users","validationUtils","normalizeMetadata","_rev","isRelatedToDeprecation","isEmpty","remote","allow_unpublish","changePackage","revision","API_MESSAGE","PKG_CHANGED","addPackage","PKG_CREATED","getBadData","BAD_PACKAGE_DATA","removePackage","PKG_REMOVED","TARBALL_REMOVED","tag","PKG_PUBLISHED","pipe","complete","abort","locals","report_error","TARBALL_UPLOADED"],"sources":["../../../../src/api/endpoint/api/publish.ts"],"sourcesContent":["import buildDebug from 'debug';\nimport type { Router } from 'express';\nimport _ from 'lodash';\nimport mime from 'mime';\nimport Path from 'path';\n\nimport type { Auth } from '@verdaccio/auth';\nimport { validationUtils } from '@verdaccio/core';\nimport { notify } from '@verdaccio/hooks';\nimport { allow, expectJson, media } from '@verdaccio/middleware';\nimport type { Callback, Config, MergeTags, Package, Version } from '@verdaccio/types';\n\nimport { API_ERROR, API_MESSAGE, DIST_TAGS, HEADERS, HTTP_STATUS } from '../../../lib/constants';\nimport { logger } from '../../../lib/logger';\nimport type Storage from '../../../lib/storage';\nimport { isPublishablePackage } from '../../../lib/storage-utils';\nimport { ErrorCode, hasDiffOneKey, isObject, isRelatedToDeprecation } from '../../../lib/utils';\nimport type { $NextFunctionVer, $RequestExtend, $ResponseExtend } from '../../../types';\nimport star from './star';\n\nconst debug = buildDebug('verdaccio:publish');\n\nexport default function publish(\n  router: Router,\n  auth: Auth,\n  storage: Storage,\n  config: Config\n): void {\n  const can = allow(auth, {\n    beforeAll: (params, message) => logger.trace(params, message),\n    afterAll: (params, message) => logger.trace(params, message),\n  });\n\n  /**\n   * Publish a package / update package / un/start a package\n   *\n   * There are multiples scenarios here to be considered:\n   *\n   * 1. Publish scenario\n   *\n   * Publish a package consist of at least 1 step (PUT) with a metadata payload.\n   * When a package is published, an _attachment property is present that contains the data\n   * of the tarball.\n   *\n   * Example flow of publish.\n   *\n   *  npm http fetch PUT 201 http://localhost:4873/@scope%2ftest1 9627ms\n      npm info lifecycle @scope/test1@1.0.1~publish: @scope/test1@1.0.1\n      npm info lifecycle @scope/test1@1.0.1~postpublish: @scope/test1@1.0.1\n      + @scope/test1@1.0.1\n      npm verb exit [ 0, true ]\n   *\n   *\n   * 2. Unpublish scenario\n   *\n   * Unpublish consist in 3 steps.\n   *  1. Try to fetch  metadata -> if it fails, return 404\n   *  2. Compute metadata locally (client side) and send a mutate payload excluding the version to be unpublished\n   *    eg: if metadata reflects 1.0.1, 1.0.2 and 1.0.3, the computed metadata won't include 1.0.3.\n   *  3. Once the second step has been successfully finished, delete the tarball.\n   *\n   *  All these steps are consecutive and required, there is no transacions here, if step 3 fails, metadata might\n   *  get corrupted.\n   *\n   *  Note the unpublish call will suffix in the url a /-rev/14-5d500cfce92f90fd revision number, this not\n   *  used internally.\n   *\n   *\n   * Example flow of unpublish.\n   *\n   * npm http fetch GET 200 http://localhost:4873/@scope%2ftest1?write=true 1680ms\n     npm http fetch PUT 201 http://localhost:4873/@scope%2ftest1/-rev/14-5d500cfce92f90fd 956606ms attempt #2\n     npm http fetch GET 200 http://localhost:4873/@scope%2ftest1?write=true 1601ms\n     npm http fetch DELETE 201 http://localhost:4873/@scope%2ftest1/-/test1-1.0.3.tgz/-rev/16-e11c8db282b2d992 19ms\n   *\n   * 3. Star a package\n   *\n   * Permissions: start a package depends of the publish and unpublish permissions, there is no specific flag for star or un start.\n   * The URL for star is similar to the unpublish (change package format)\n   *\n   * npm has no enpoint for star a package, rather mutate the metadata and acts as, the difference is the\n   * users property which is part of the payload and the body only includes\n   *\n   * {\n\t\t  \"_id\": pkgName,\n\t  \t\"_rev\": \"3-b0cdaefc9bdb77c8\",\n\t\t  \"users\": {\n\t\t    [username]: boolean value (true, false)\n\t\t  }\n\t}\n   *\n   */\n  router.put(\n    '/:package/:_rev?/:revision?',\n    can('publish'),\n    media(mime.getType('json')),\n    expectJson,\n    publishPackage(storage, config, auth)\n  );\n\n  /**\n   * Un-publishing an entire package.\n   *\n   * This scenario happens when the first call detect there is only one version remaining\n   * in the metadata, then the client decides to DELETE the resource\n   * npm http fetch GET 304 http://localhost:4873/@scope%2ftest1?write=true 1076ms (from cache)\n     npm http fetch DELETE 201 http://localhost:4873/@scope%2ftest1/-rev/18-d8ebe3020bd4ac9c 22ms\n   */\n  router.delete('/:package/-rev/*', can('unpublish'), unPublishPackage(storage));\n\n  // removing a tarball\n  router.delete(\n    '/:package/-/:filename/-rev/:revision',\n    can('unpublish'),\n    can('publish'),\n    removeTarball(storage)\n  );\n\n  // uploading package tarball\n  router.put(\n    '/:package/-/:filename/*',\n    can('publish'),\n    media(HEADERS.OCTET_STREAM),\n    uploadPackageTarball(storage)\n  );\n\n  // only used for development\n  if (config._debug) {\n    // adding a version\n    router.put(\n      '/:package/:version/-tag/:tag',\n      can('publish'),\n      media(mime.getType('json')),\n      expectJson,\n      addVersion(storage)\n    );\n  }\n}\n\n/**\n * Publish a package\n */\nexport function publishPackage(storage: Storage, config: Config, auth: Auth): any {\n  const starApi = star(storage);\n  return function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer): void {\n    const packageName = req.params.package;\n    debug('publishing or updating a new version for %o', packageName);\n    /**\n     * Write tarball of stream data from package clients.\n     */\n    const createTarball = function (filename: string, data, cb: Callback): void {\n      const stream = storage.addTarball(packageName, filename);\n      stream.on('error', function (err) {\n        cb(err);\n      });\n      stream.on('success', function () {\n        cb();\n      });\n      // this is dumb and memory-consuming, but what choices do we have?\n      // flow: we need first refactor this file before decides which type use here\n      stream.end(Buffer.from(data.data, 'base64'));\n      stream.done();\n    };\n\n    /**\n     * Add new package version in storage\n     */\n    const createVersion = function (version: string, metadata: Version, cb: Callback): void {\n      storage.addVersion(packageName, version, metadata, null, cb);\n    };\n\n    /**\n     * Add new tags in storage\n     */\n    const addTags = function (tags: MergeTags, cb: Callback): void {\n      storage.mergeTags(packageName, tags, cb);\n    };\n\n    const afterChange = function (error, okMessage, metadata): void {\n      const metadataCopy: Package = { ...metadata };\n\n      const { _attachments, versions } = metadataCopy;\n\n      // `npm star` wouldn't have attachments\n      // and `npm deprecate` would have attachments as a empty object, i.e {}\n      if (_.isNil(_attachments) || JSON.stringify(_attachments) === '{}') {\n        if (error) {\n          return next(error);\n        }\n        res.status(HTTP_STATUS.CREATED);\n        return next({\n          ok: okMessage,\n          success: true,\n        });\n      }\n\n      // npm-registry-client 0.3+ embeds tarball into the json upload\n      // https://github.com/isaacs/npm-registry-client/commit/e9fbeb8b67f249394f735c74ef11fe4720d46ca0\n      // issue https://github.com/rlidwka/sinopia/issues/31, dealing with it here:\n      const isInvalidBodyFormat =\n        isObject(_attachments) === false ||\n        hasDiffOneKey(_attachments) ||\n        isObject(versions) === false ||\n        hasDiffOneKey(versions);\n\n      if (isInvalidBodyFormat) {\n        // npm is doing something strange again\n        // if this happens in normal circumstances, report it as a bug\n        logger.info({ packageName }, `wrong package format on publish a package @{packageName}`);\n        return next(ErrorCode.getBadRequest(API_ERROR.UNSUPORTED_REGISTRY_CALL));\n      }\n\n      if (error && error.status !== HTTP_STATUS.CONFLICT) {\n        return next(error);\n      }\n\n      // at this point document is either created or existed before\n      const [firstAttachmentKey] = Object.keys(_attachments);\n\n      createTarball(\n        Path.basename(firstAttachmentKey),\n        _attachments[firstAttachmentKey],\n        function (error) {\n          if (error) {\n            return next(error);\n          }\n\n          const versionToPublish = Object.keys(versions)[0];\n          const versionMetadataToPublish = versions[versionToPublish];\n\n          versionMetadataToPublish.readme =\n            _.isNil(versionMetadataToPublish.readme) === false\n              ? String(versionMetadataToPublish.readme)\n              : '';\n\n          createVersion(versionToPublish, versionMetadataToPublish, function (error) {\n            if (error) {\n              return next(error);\n            }\n\n            addTags(metadataCopy[DIST_TAGS], async function (error) {\n              if (error) {\n                return next(error);\n              }\n\n              try {\n                await notify(\n                  metadataCopy,\n                  config,\n                  req.remote_user,\n                  `${metadataCopy.name}@${versionToPublish}`\n                );\n              } catch (error) {\n                logger.error({ error }, 'notify batch service has failed: @{error}');\n              }\n\n              res.status(HTTP_STATUS.CREATED);\n              return next({ ok: okMessage, success: true });\n            });\n          });\n        }\n      );\n    };\n\n    if (isPublishablePackage(req.body) === false && isObject(req.body.users)) {\n      return starApi(req, res, next);\n    }\n\n    try {\n      const metadata = validationUtils.normalizeMetadata(req.body, packageName);\n      // check _attachments to distinguish publish and deprecate\n      if (\n        req.params._rev ||\n        (isRelatedToDeprecation(req.body) && _.isEmpty(req.body._attachments))\n      ) {\n        debug('updating a new version for %o', packageName);\n        // we check unpublish permissions, an update is basically remove versions\n        const remote = req.remote_user;\n        auth.allow_unpublish({ packageName }, remote, (error) => {\n          if (error) {\n            logger.error({ packageName }, `not allowed to unpublish a version for @{packageName}`);\n            return next(error);\n          }\n          storage.changePackage(packageName, metadata, req.params.revision, function (error) {\n            afterChange(error, API_MESSAGE.PKG_CHANGED, metadata);\n          });\n        });\n      } else {\n        debug('adding a new version for %o', packageName);\n        storage.addPackage(packageName, metadata, function (error) {\n          afterChange(error, API_MESSAGE.PKG_CREATED, metadata);\n        });\n      }\n    } catch (error: any) {\n      debug('error on publish: %s', error.message);\n      logger.error({ packageName }, 'error on publish, bad package data for @{packageName}');\n      return next(ErrorCode.getBadData(API_ERROR.BAD_PACKAGE_DATA));\n    }\n  };\n}\n\n/**\n * un-publish a package\n */\nexport function unPublishPackage(storage: Storage) {\n  return function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer): void {\n    const packageName = req.params.package;\n    debug('unpublishing %o', packageName);\n    storage.removePackage(packageName, function (err) {\n      if (err) {\n        return next(err);\n      }\n      res.status(HTTP_STATUS.CREATED);\n      return next({ ok: API_MESSAGE.PKG_REMOVED });\n    });\n  };\n}\n\n/**\n * Delete tarball\n */\nexport function removeTarball(storage: Storage) {\n  return function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer): void {\n    const packageName = req.params.package;\n    const { filename, revision } = req.params;\n    debug('removing a tarball for %o-%o-%o', packageName, filename, revision);\n    storage.removeTarball(packageName, filename, revision, function (err) {\n      if (err) {\n        return next(err);\n      }\n      res.status(HTTP_STATUS.CREATED);\n      debug('success remove tarball for %o-%o-%o', packageName, filename, revision);\n      return next({ ok: API_MESSAGE.TARBALL_REMOVED });\n    });\n  };\n}\n/**\n * Adds a new version\n */\nexport function addVersion(storage: Storage) {\n  return function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer): void {\n    const { version, tag } = req.params;\n    const packageName = req.params.package;\n\n    storage.addVersion(packageName, version, req.body, tag, function (error) {\n      if (error) {\n        return next(error);\n      }\n\n      res.status(HTTP_STATUS.CREATED);\n      return next({\n        ok: API_MESSAGE.PKG_PUBLISHED,\n      });\n    });\n  };\n}\n\n/**\n * uploadPackageTarball\n */\nexport function uploadPackageTarball(storage: Storage) {\n  return function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer): void {\n    const packageName = req.params.package;\n    const stream = storage.addTarball(packageName, req.params.filename);\n    req.pipe(stream);\n\n    // checking if end event came before closing\n    let complete = false;\n    req.on('end', function () {\n      complete = true;\n      stream.done();\n    });\n\n    req.on('close', function () {\n      if (!complete) {\n        stream.abort();\n      }\n    });\n\n    stream.on('error', function (err) {\n      return res.locals.report_error(err);\n    });\n\n    stream.on('success', function () {\n      res.status(HTTP_STATUS.CREATED);\n      return next({\n        ok: API_MESSAGE.TARBALL_UPLOADED,\n      });\n    });\n  };\n}\n"],"mappings":"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","ignoreList":[]}

package/build/api/endpoint/api/search.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _middleware = require("@verdaccio/middleware");
+var _constants = require("../../../lib/constants");
+var _logger = require("../../../lib/logger");
+function _default(route, auth, storage) {
+  // searching packages
+  route.get(_middleware.SEARCH_API_ENDPOINTS.deprecated_search, function (req, res) {
+    let received_end = false;
+    let response_finished = false;
+    let processing_pkgs = 0;
+    let firstPackage = true;
+    _logger.logger.warn('/-/all search endpoint is deprecated, might be removed in the next major release');
+    res.status(200);
+    res.set(_constants.HEADERS.CONTENT_TYPE, _constants.HEADERS.JSON_CHARSET);
+
+    /*
+     * Offical NPM registry (registry.npmjs.org) no longer return whole database,
+     * They only return packages matched with keyword in `referer: search pkg-name`,
+     * And NPM client will request server in every search.
+     *
+     * The magic number 99999 was sent by NPM registry. Modify it may caused strange
+     * behaviour in the future.
+     *
+     * BTW: NPM will not return result if user-agent does not contain string 'npm',
+     * See: method 'request' in up-storage.js
+     *
+     * If there is no cache in local, NPM will request /-/all, then get response with
+     * _updated: 99999, 'Date' in response header was Mon, 10 Oct 1983 00:12:48 GMT,
+     * this will make NPM always query from server
+     *
+     * Data structure also different, whel request /-/all, response is an object, but
+     * when request /-/all/since, response is an array
+     */
+    const respShouldBeArray = req.path.endsWith('/since');
+    if (!respShouldBeArray) {
+      res.set('Date', 'Mon, 10 Oct 1983 00:12:48 GMT');
+    }
+    const check_finish = function () {
+      if (!received_end) {
+        return;
+      }
+      if (processing_pkgs) {
+        return;
+      }
+      if (response_finished) {
+        return;
+      }
+      response_finished = true;
+      if (respShouldBeArray) {
+        res.end(']\n');
+      } else {
+        res.end('}\n');
+      }
+    };
+    if (respShouldBeArray) {
+      res.write('[');
+    } else {
+      res.write('{"_updated":' + 99999);
+    }
+    const stream = storage.search(req.query.startkey || 0, {
+      req: req
+    });
+    stream.on('data', function each(pkg) {
+      processing_pkgs++;
+      auth.allow_access({
+        packageName: pkg.name
+      }, req.remote_user, function (err, allowed) {
+        processing_pkgs--;
+        if (err) {
+          if (err.status && String(err.status).match(/^4\d\d$/)) {
+            // auth plugin returns 4xx user error,
+            // that's equivalent of !allowed basically
+            allowed = false;
+          } else {
+            stream.abort(err);
+          }
+        }
+        if (allowed) {
+          if (respShouldBeArray) {
+            res.write(`${firstPackage ? '' : ','}${JSON.stringify(pkg)}\n`);
+            if (firstPackage) {
+              firstPackage = false;
+            }
+          } else {
+            res.write(',\n' + JSON.stringify(pkg.name) + ':' + JSON.stringify(pkg));
+          }
+        }
+        check_finish();
+      });
+    });
+    stream.on('error', function (err) {
+      _logger.logger.error('search `/-/all endpoint has failed @{err}', err);
+      received_end = true;
+      check_finish();
+    });
+    stream.on('end', function () {
+      received_end = true;
+      check_finish();
+    });
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_middleware","require","_constants","_logger","_default","route","auth","storage","get","SEARCH_API_ENDPOINTS","deprecated_search","req","res","received_end","response_finished","processing_pkgs","firstPackage","logger","warn","status","set","HEADERS","CONTENT_TYPE","JSON_CHARSET","respShouldBeArray","path","endsWith","check_finish","end","write","stream","search","query","startkey","on","each","pkg","allow_access","packageName","name","remote_user","err","allowed","String","match","abort","JSON","stringify","error"],"sources":["../../../../src/api/endpoint/api/search.ts"],"sourcesContent":["import { SEARCH_API_ENDPOINTS } from '@verdaccio/middleware';\n\nimport { HEADERS } from '../../../lib/constants';\nimport { logger } from '../../../lib/logger';\n\nexport default function (route, auth, storage): void {\n  // searching packages\n  route.get(SEARCH_API_ENDPOINTS.deprecated_search, function (req, res) {\n    let received_end = false;\n    let response_finished = false;\n    let processing_pkgs = 0;\n    let firstPackage = true;\n    logger.warn('/-/all search endpoint is deprecated, might be removed in the next major release');\n    res.status(200);\n    res.set(HEADERS.CONTENT_TYPE, HEADERS.JSON_CHARSET);\n\n    /*\n     * Offical NPM registry (registry.npmjs.org) no longer return whole database,\n     * They only return packages matched with keyword in `referer: search pkg-name`,\n     * And NPM client will request server in every search.\n     *\n     * The magic number 99999 was sent by NPM registry. Modify it may caused strange\n     * behaviour in the future.\n     *\n     * BTW: NPM will not return result if user-agent does not contain string 'npm',\n     * See: method 'request' in up-storage.js\n     *\n     * If there is no cache in local, NPM will request /-/all, then get response with\n     * _updated: 99999, 'Date' in response header was Mon, 10 Oct 1983 00:12:48 GMT,\n     * this will make NPM always query from server\n     *\n     * Data structure also different, whel request /-/all, response is an object, but\n     * when request /-/all/since, response is an array\n     */\n    const respShouldBeArray = req.path.endsWith('/since');\n    if (!respShouldBeArray) {\n      res.set('Date', 'Mon, 10 Oct 1983 00:12:48 GMT');\n    }\n    const check_finish = function (): void {\n      if (!received_end) {\n        return;\n      }\n      if (processing_pkgs) {\n        return;\n      }\n      if (response_finished) {\n        return;\n      }\n      response_finished = true;\n      if (respShouldBeArray) {\n        res.end(']\\n');\n      } else {\n        res.end('}\\n');\n      }\n    };\n\n    if (respShouldBeArray) {\n      res.write('[');\n    } else {\n      res.write('{\"_updated\":' + 99999);\n    }\n\n    const stream = storage.search(req.query.startkey || 0, { req: req });\n\n    stream.on('data', function each(pkg) {\n      processing_pkgs++;\n\n      auth.allow_access({ packageName: pkg.name }, req.remote_user, function (err, allowed) {\n        processing_pkgs--;\n\n        if (err) {\n          if (err.status && String(err.status).match(/^4\\d\\d$/)) {\n            // auth plugin returns 4xx user error,\n            // that's equivalent of !allowed basically\n            allowed = false;\n          } else {\n            stream.abort(err);\n          }\n        }\n\n        if (allowed) {\n          if (respShouldBeArray) {\n            res.write(`${firstPackage ? '' : ','}${JSON.stringify(pkg)}\\n`);\n            if (firstPackage) {\n              firstPackage = false;\n            }\n          } else {\n            res.write(',\\n' + JSON.stringify(pkg.name) + ':' + JSON.stringify(pkg));\n          }\n        }\n\n        check_finish();\n      });\n    });\n\n    stream.on('error', function (err) {\n      logger.error('search `/-/all endpoint has failed @{err}', err);\n      received_end = true;\n      check_finish();\n    });\n\n    stream.on('end', function () {\n      received_end = true;\n      check_finish();\n    });\n  });\n}\n"],"mappings":"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","ignoreList":[]}

package/build/api/endpoint/api/star.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _debug = _interopRequireDefault(require("debug"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _constants = require("../../../lib/constants");
+var _logger = require("../../../lib/logger");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const debug = (0, _debug.default)('verdaccio:star');
+function _default(storage) {
+  const validateInputs = (newUsers, localUsers, username, isStar) => {
+    const isExistlocalUsers = _lodash.default.isNil(localUsers[username]) === false;
+    if (isStar && isExistlocalUsers && localUsers[username]) {
+      return true;
+    } else if (!isStar && isExistlocalUsers) {
+      return false;
+    } else if (!isStar && !isExistlocalUsers) {
+      return true;
+    }
+    return false;
+  };
+  return (req, res, next) => {
+    const name = req.params.package;
+    debug('starring a package for %o', name);
+    const afterChangePackage = function (err) {
+      if (err) {
+        return next(err);
+      }
+      _logger.logger.debug(`package ${name} starred by user ${req.remote_user?.name}`);
+      // we do not need
+      res.status(_constants.HTTP_STATUS.OK);
+      next({
+        success: true
+      });
+    };
+    storage.getPackage({
+      name,
+      req,
+      callback: function (err, info) {
+        if (err) {
+          return next(err);
+        }
+        const newStarUser = req.body[_constants.USERS];
+        const remoteUsername = req.remote_user.name;
+        const localStarUsers = info[_constants.USERS];
+        // Check is star or unstar
+        const isStar = Object.keys(newStarUser).includes(remoteUsername);
+        if (_lodash.default.isNil(localStarUsers) === false && validateInputs(newStarUser, localStarUsers, remoteUsername, isStar)) {
+          return afterChangePackage();
+        }
+        const users = isStar ? {
+          ...localStarUsers,
+          [remoteUsername]: true
+        } : _lodash.default.reduce(localStarUsers, (users, value, key) => {
+          if (key !== remoteUsername) {
+            users[key] = value;
+          }
+          return users;
+        }, {});
+        storage.changePackage(name, {
+          ...info,
+          users
+        }, req.body._rev, function (err) {
+          afterChangePackage(err);
+        });
+      }
+    });
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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