@verdaccio/canary 6.3.2-canary.404363f

package/build/api/endpoint/api/stars.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _debug = _interopRequireDefault(require("debug"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _core = require("@verdaccio/core");
+var _middleware = require("@verdaccio/middleware");
+var _constants = require("../../../lib/constants");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const debug = (0, _debug.default)('verdaccio:api:stars');
+function _default(route, storage) {
+  route.get(_middleware.STARS_API_ENDPOINTS.get_user_starred_packages, (req, res, next) => {
+    const query = req.query;
+    if (typeof query?.key === 'undefined' || typeof query?.key !== 'string') {
+      debug('missing query key username');
+      return next(_core.errorUtils.getBadRequest('missing query key username'));
+    }
+    const key = query.key;
+    debug(`get user starred packages for user: ${key}`);
+    storage.getLocalDatabase((err, localPackages) => {
+      if (err) {
+        debug(`error getting local database: ${err.message}`);
+        return next(err);
+      }
+      const filteredPackages = localPackages.filter(localPackage => {
+        debug(`checking package: ${localPackage?.name}`);
+        return _lodash.default.keys(localPackage[_constants.USERS]).includes(key.toString().replace(/['"]+/g, ''));
+      });
+      debug(`found ${filteredPackages.length} packages for user: ${key}`);
+      res.status(_constants.HTTP_STATUS.OK);
+      next({
+        rows: filteredPackages.map(filteredPackage => ({
+          value: filteredPackage.name
+        }))
+      });
+    });
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/api/endpoint/api/user.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _express = _interopRequireDefault(require("express"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _auth = require("@verdaccio/auth");
+var _config = require("@verdaccio/config");
+var _core = require("@verdaccio/core");
+var _middleware = require("@verdaccio/middleware");
+var _utils = require("@verdaccio/utils");
+var _constants = require("../../../lib/constants");
+var _logger = require("../../../lib/logger");
+var _utils2 = require("../../../lib/utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _default(route, auth, config) {
+  /* eslint new-cap:off */
+  const userRouter = _express.default.Router();
+  userRouter.get('/-/user/:org_couchdb_user', (0, _middleware.rateLimit)(config?.userRateLimit), function (req, res, next) {
+    res.status(_constants.HTTP_STATUS.OK);
+    next({
+      ok: (0, _utils.getAuthenticatedMessage)(req.remote_user.name)
+    });
+  });
+  userRouter.put('/-/user/:org_couchdb_user/:_rev?/:revision?', (0, _middleware.rateLimit)(config?.userRateLimit), function (req, res, next) {
+    const {
+      name,
+      password
+    } = req.body;
+    const remoteName = req.remote_user.name;
+    if (_lodash.default.isNil(remoteName) === false && _lodash.default.isNil(name) === false && remoteName === name) {
+      auth.authenticate(name, password, async function callbackAuthenticate(err, user) {
+        if (err) {
+          _logger.logger.error({
+            name,
+            err
+          }, 'authenticating for user @{username} failed. Error: @{err.message}');
+          return next(_utils2.ErrorCode.getCode(_constants.HTTP_STATUS.UNAUTHORIZED, _constants.API_ERROR.BAD_USERNAME_PASSWORD));
+        }
+        const restoredRemoteUser = (0, _config.createRemoteUser)(name, user?.groups ?? []);
+        const token = await (0, _auth.getApiToken)(auth, config, restoredRemoteUser, password);
+        res.status(_constants.HTTP_STATUS.CREATED);
+        res.set(_constants.HEADERS.CACHE_CONTROL, 'no-cache, no-store');
+        return next({
+          ok: (0, _utils.getAuthenticatedMessage)(req.remote_user.name),
+          token
+        });
+      });
+    } else {
+      if (_core.validationUtils.validatePassword(password) === false) {
+        return next(_utils2.ErrorCode.getCode(_constants.HTTP_STATUS.BAD_REQUEST, _constants.API_ERROR.PASSWORD_SHORT));
+      }
+      auth.add_user(name, password, async function (err, user) {
+        if (err) {
+          if (err.status >= _constants.HTTP_STATUS.BAD_REQUEST && err.status < _constants.HTTP_STATUS.INTERNAL_ERROR) {
+            // With npm registering is the same as logging in,
+            // and npm accepts only an 409 error.
+            // So, changing status code here.
+            return next(_utils2.ErrorCode.getCode(err.status, err.message) || _utils2.ErrorCode.getConflict(err.message));
+          }
+          return next(err);
+        }
+        const token = name && password ? await (0, _auth.getApiToken)(auth, config, user, password) : undefined;
+        req.remote_user = user;
+        res.status(_constants.HTTP_STATUS.CREATED);
+        res.set(_constants.HEADERS.CACHE_CONTROL, 'no-cache, no-store');
+        return next({
+          ok: `user '${req.body.name}' created`,
+          token
+        });
+      });
+    }
+  });
+  userRouter.delete('/-/user/token/*', (0, _middleware.rateLimit)(config?.userRateLimit), function (req, res, next) {
+    res.status(_constants.HTTP_STATUS.OK);
+    next({
+      ok: _constants.API_MESSAGE.LOGGED_OUT
+    });
+  });
+  route.use(userRouter);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_express","_interopRequireDefault","require","_lodash","_auth","_config","_core","_middleware","_utils","_constants","_logger","_utils2","e","__esModule","default","_default","route","auth","config","userRouter","express","Router","get","rateLimit","userRateLimit","req","res","next","status","HTTP_STATUS","OK","ok","getAuthenticatedMessage","remote_user","name","put","password","body","remoteName","_","isNil","authenticate","callbackAuthenticate","err","user","logger","error","ErrorCode","getCode","UNAUTHORIZED","API_ERROR","BAD_USERNAME_PASSWORD","restoredRemoteUser","createRemoteUser","groups","token","getApiToken","CREATED","set","HEADERS","CACHE_CONTROL","validationUtils","validatePassword","BAD_REQUEST","PASSWORD_SHORT","add_user","INTERNAL_ERROR","message","getConflict","undefined","delete","API_MESSAGE","LOGGED_OUT","use"],"sources":["../../../../src/api/endpoint/api/user.ts"],"sourcesContent":["import type { Response, Router } from 'express';\nimport express from 'express';\nimport _ from 'lodash';\n\nimport { getApiToken } from '@verdaccio/auth';\nimport type { Auth } from '@verdaccio/auth';\nimport { createRemoteUser } from '@verdaccio/config';\nimport { validationUtils } from '@verdaccio/core';\nimport { rateLimit } from '@verdaccio/middleware';\nimport type { Config, RemoteUser } from '@verdaccio/types';\nimport { getAuthenticatedMessage } from '@verdaccio/utils';\n\nimport { API_ERROR, API_MESSAGE, HEADERS, HTTP_STATUS } from '../../../lib/constants';\nimport { logger } from '../../../lib/logger';\nimport { ErrorCode } from '../../../lib/utils';\nimport type { $NextFunctionVer, $RequestExtend } from '../../../types';\n\nexport default function (route: Router, auth: Auth, config: Config): void {\n  /* eslint new-cap:off */\n  const userRouter = express.Router();\n\n  userRouter.get(\n    '/-/user/:org_couchdb_user',\n    rateLimit(config?.userRateLimit),\n    function (req: $RequestExtend, res: Response, next: $NextFunctionVer): void {\n      res.status(HTTP_STATUS.OK);\n      next({\n        ok: getAuthenticatedMessage(req.remote_user.name),\n      });\n    }\n  );\n\n  userRouter.put(\n    '/-/user/:org_couchdb_user/:_rev?/:revision?',\n    rateLimit(config?.userRateLimit),\n    function (req: $RequestExtend, res: Response, next: $NextFunctionVer): void {\n      const { name, password } = req.body;\n      const remoteName = req.remote_user.name;\n\n      if (_.isNil(remoteName) === false && _.isNil(name) === false && remoteName === name) {\n        auth.authenticate(\n          name,\n          password,\n          async function callbackAuthenticate(err, user): Promise<void> {\n            if (err) {\n              logger.error(\n                { name, err },\n                'authenticating for user @{username} failed. Error: @{err.message}'\n              );\n              return next(\n                ErrorCode.getCode(HTTP_STATUS.UNAUTHORIZED, API_ERROR.BAD_USERNAME_PASSWORD)\n              );\n            }\n\n            const restoredRemoteUser: RemoteUser = createRemoteUser(name, user?.groups ?? []);\n            const token = await getApiToken(auth, config, restoredRemoteUser, password);\n\n            res.status(HTTP_STATUS.CREATED);\n            res.set(HEADERS.CACHE_CONTROL, 'no-cache, no-store');\n            return next({\n              ok: getAuthenticatedMessage(req.remote_user.name),\n              token,\n            });\n          }\n        );\n      } else {\n        if (validationUtils.validatePassword(password) === false) {\n          return next(ErrorCode.getCode(HTTP_STATUS.BAD_REQUEST, API_ERROR.PASSWORD_SHORT));\n        }\n\n        auth.add_user(name, password, async function (err, user): Promise<void> {\n          if (err) {\n            if (err.status >= HTTP_STATUS.BAD_REQUEST && err.status < HTTP_STATUS.INTERNAL_ERROR) {\n              // With npm registering is the same as logging in,\n              // and npm accepts only an 409 error.\n              // So, changing status code here.\n              return next(\n                ErrorCode.getCode(err.status, err.message) || ErrorCode.getConflict(err.message)\n              );\n            }\n            return next(err);\n          }\n\n          const token =\n            name && password\n              ? await getApiToken(auth, config, user as RemoteUser, password)\n              : undefined;\n\n          req.remote_user = user;\n          res.status(HTTP_STATUS.CREATED);\n          res.set(HEADERS.CACHE_CONTROL, 'no-cache, no-store');\n          return next({\n            ok: `user '${req.body.name}' created`,\n            token,\n          });\n        });\n      }\n    }\n  );\n\n  userRouter.delete(\n    '/-/user/token/*',\n    rateLimit(config?.userRateLimit),\n    function (req: $RequestExtend, res: Response, next: $NextFunctionVer): void {\n      res.status(HTTP_STATUS.OK);\n      next({\n        ok: API_MESSAGE.LOGGED_OUT,\n      });\n    }\n  );\n\n  route.use(userRouter);\n}\n"],"mappings":"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","ignoreList":[]}

package/build/api/endpoint/api/v1/profile.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _lodash = _interopRequireDefault(require("lodash"));
+var _core = require("@verdaccio/core");
+var _middleware = require("@verdaccio/middleware");
+var _constants = require("../../../../lib/constants");
+var _utils = require("../../../../lib/utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _default(router, auth, config) {
+  function buildProfile(name) {
+    return {
+      tfa: false,
+      name,
+      email: '',
+      email_verified: false,
+      created: '',
+      updated: '',
+      cidr_whitelist: null,
+      fullname: ''
+    };
+  }
+  router.get('/-/npm/v1/user', (0, _middleware.rateLimit)(config?.userRateLimit), function (req, res, next) {
+    if (_lodash.default.isNil(req.remote_user.name) === false) {
+      return next(buildProfile(req.remote_user.name));
+    }
+    res.status(_constants.HTTP_STATUS.UNAUTHORIZED);
+    return next({
+      message: _constants.API_ERROR.MUST_BE_LOGGED
+    });
+  });
+  router.post('/-/npm/v1/user', (0, _middleware.rateLimit)(config?.userRateLimit), function (req, res, next) {
+    if (_lodash.default.isNil(req.remote_user.name)) {
+      res.status(_constants.HTTP_STATUS.UNAUTHORIZED);
+      return next({
+        message: _constants.API_ERROR.MUST_BE_LOGGED
+      });
+    }
+    const {
+      password,
+      tfa
+    } = req.body;
+    const {
+      name
+    } = req.remote_user;
+    if (_lodash.default.isNil(password) === false) {
+      if (_core.validationUtils.validatePassword(password.new) === false) {
+        return next(_utils.ErrorCode.getCode(_constants.HTTP_STATUS.UNAUTHORIZED, _constants.API_ERROR.PASSWORD_SHORT));
+      }
+      auth.changePassword(name, password.old, password.new, (err, isUpdated) => {
+        if (_lodash.default.isNull(err) === false) {
+          return next(_utils.ErrorCode.getCode(err.status, err.message) || _utils.ErrorCode.getConflict(err.message));
+        }
+        if (isUpdated) {
+          return next(buildProfile(req.remote_user.name));
+        }
+        return next(_utils.ErrorCode.getInternalError(_constants.API_ERROR.INTERNAL_SERVER_ERROR));
+      });
+    } else if (_lodash.default.isNil(tfa) === false) {
+      return next(_utils.ErrorCode.getCode(_constants.HTTP_STATUS.SERVICE_UNAVAILABLE, _constants.SUPPORT_ERRORS.TFA_DISABLED));
+    } else {
+      return next(_utils.ErrorCode.getCode(_constants.HTTP_STATUS.INTERNAL_ERROR, _constants.APP_ERROR.PROFILE_ERROR));
+    }
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_lodash","_interopRequireDefault","require","_core","_middleware","_constants","_utils","e","__esModule","default","_default","router","auth","config","buildProfile","name","tfa","email","email_verified","created","updated","cidr_whitelist","fullname","get","rateLimit","userRateLimit","req","res","next","_","isNil","remote_user","status","HTTP_STATUS","UNAUTHORIZED","message","API_ERROR","MUST_BE_LOGGED","post","password","body","validationUtils","validatePassword","new","ErrorCode","getCode","PASSWORD_SHORT","changePassword","old","err","isUpdated","isNull","getConflict","getInternalError","INTERNAL_SERVER_ERROR","SERVICE_UNAVAILABLE","SUPPORT_ERRORS","TFA_DISABLED","INTERNAL_ERROR","APP_ERROR","PROFILE_ERROR"],"sources":["../../../../../src/api/endpoint/api/v1/profile.ts"],"sourcesContent":["import type { Response, Router } from 'express';\nimport _ from 'lodash';\n\nimport type { Auth } from '@verdaccio/auth';\nimport { validationUtils } from '@verdaccio/core';\nimport { rateLimit } from '@verdaccio/middleware';\nimport type { ConfigYaml } from '@verdaccio/types';\n\nimport { API_ERROR, APP_ERROR, HTTP_STATUS, SUPPORT_ERRORS } from '../../../../lib/constants';\nimport { ErrorCode } from '../../../../lib/utils';\nimport type { $NextFunctionVer, $RequestExtend } from '../../../../types';\n\nexport interface Profile {\n  tfa: boolean;\n  name: string;\n  email: string;\n  email_verified: boolean;\n  created: string;\n  updated: string;\n  cidr_whitelist: string[] | null;\n  fullname: string;\n}\n\nexport default function (router: Router, auth: Auth, config: ConfigYaml) {\n  function buildProfile(name: string): Profile {\n    return {\n      tfa: false,\n      name,\n      email: '',\n      email_verified: false,\n      created: '',\n      updated: '',\n      cidr_whitelist: null,\n      fullname: '',\n    };\n  }\n\n  router.get(\n    '/-/npm/v1/user',\n    rateLimit(config?.userRateLimit),\n    function (req: $RequestExtend, res: Response, next: $NextFunctionVer): void {\n      if (_.isNil(req.remote_user.name) === false) {\n        return next(buildProfile(req.remote_user.name));\n      }\n\n      res.status(HTTP_STATUS.UNAUTHORIZED);\n      return next({\n        message: API_ERROR.MUST_BE_LOGGED,\n      });\n    }\n  );\n\n  router.post(\n    '/-/npm/v1/user',\n    rateLimit(config?.userRateLimit),\n    function (req: $RequestExtend, res: Response, next: $NextFunctionVer): void {\n      if (_.isNil(req.remote_user.name)) {\n        res.status(HTTP_STATUS.UNAUTHORIZED);\n        return next({\n          message: API_ERROR.MUST_BE_LOGGED,\n        });\n      }\n\n      const { password, tfa } = req.body;\n      const { name } = req.remote_user;\n\n      if (_.isNil(password) === false) {\n        if (validationUtils.validatePassword(password.new) === false) {\n          return next(ErrorCode.getCode(HTTP_STATUS.UNAUTHORIZED, API_ERROR.PASSWORD_SHORT));\n        }\n\n        auth.changePassword(\n          name,\n          password.old,\n          password.new,\n          (err, isUpdated): $NextFunctionVer => {\n            if (_.isNull(err) === false) {\n              return next(\n                ErrorCode.getCode(err.status, err.message) || ErrorCode.getConflict(err.message)\n              );\n            }\n\n            if (isUpdated) {\n              return next(buildProfile(req.remote_user.name));\n            }\n            return next(ErrorCode.getInternalError(API_ERROR.INTERNAL_SERVER_ERROR));\n          }\n        );\n      } else if (_.isNil(tfa) === false) {\n        return next(\n          ErrorCode.getCode(HTTP_STATUS.SERVICE_UNAVAILABLE, SUPPORT_ERRORS.TFA_DISABLED)\n        );\n      } else {\n        return next(ErrorCode.getCode(HTTP_STATUS.INTERNAL_ERROR, APP_ERROR.PROFILE_ERROR));\n      }\n    }\n  );\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,181 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _lodash = _interopRequireDefault(require("lodash"));
+var _semver = _interopRequireDefault(require("semver"));
+var _middleware = require("@verdaccio/middleware");
+var _constants = require("../../../../lib/constants");
+var _logger = require("../../../../lib/logger");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const personMatch = (person, search) => {
+  if (typeof person === 'string') {
+    return person.includes(search);
+  }
+  if (typeof person === 'object') {
+    for (const field of Object.values(person)) {
+      if (typeof field === 'string' && field.includes(search)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+const matcher = function (query) {
+  const match = query.match(/author:(.*)/);
+  if (match !== null) {
+    return function (pkg) {
+      return personMatch(pkg.author, match[1]);
+    };
+  }
+
+  // TODO: maintainer, keywords, boost-exact
+  // TODO implement some scoring system for freetext
+  return pkg => {
+    return ['name', 'displayName', 'description'].map(k => {
+      return pkg[k];
+    }).filter(x => {
+      return x !== undefined;
+    }).some(txt => {
+      return txt.includes(query);
+    });
+  };
+};
+function compileTextSearch(textSearch) {
+  const textMatchers = (textSearch || '').split(' ').map(matcher);
+  return pkg => textMatchers.every(m => m(pkg));
+}
+function removeDuplicates(results) {
+  const pkgNames = [];
+  return results.filter(pkg => {
+    if (pkgNames.includes(pkg?.package?.name)) {
+      return false;
+    }
+    pkgNames.push(pkg?.package?.name);
+    return true;
+  });
+}
+function checkAccess(pkg, auth, remoteUser) {
+  return new Promise((resolve, reject) => {
+    auth.allow_access({
+      packageName: pkg?.package?.name
+    }, remoteUser, function (err, allowed) {
+      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;
+          return resolve(null);
+        } else {
+          reject(err);
+        }
+      } else {
+        return resolve(allowed ? pkg : null);
+      }
+    });
+  });
+}
+async function sendResponse(resultBuf, resultStream, auth, req, from, size) {
+  resultStream.destroy();
+  const resultsCollection = resultBuf.map(pkg => {
+    if (pkg?.name) {
+      return {
+        package: pkg,
+        // not sure if flags is need it
+        flags: {
+          unstable: Object.keys(pkg.versions).some(v => _semver.default.satisfies(v, '^1.0.0')) ? undefined : true
+        },
+        local: true,
+        score: {
+          final: 1,
+          detail: {
+            quality: 1,
+            popularity: 1,
+            maintenance: 0
+          }
+        },
+        searchScore: 100000
+      };
+    } else {
+      return pkg;
+    }
+  });
+  const checkAccessPromises = await Promise.all(removeDuplicates(resultsCollection).map(pkgItem => {
+    return checkAccess(pkgItem, auth, req.remote_user);
+  }));
+  const final = checkAccessPromises.filter(i => !_lodash.default.isNull(i)).slice(from, size);
+  _logger.logger.debug(`search results ${final?.length}`);
+  const response = {
+    objects: final,
+    total: final.length,
+    time: new Date().toUTCString()
+  };
+  _logger.logger.debug(`total response ${final.length}`);
+  return response;
+}
+
+/**
+ * Endpoint for npm search v1
+ * req: 'GET /-/v1/search?text=react&size=20&from=0&quality=0.65&popularity=0.98&maintenance=0.5'
+ */
+function _default(route, auth, storage) {
+  route.get(_middleware.SEARCH_API_ENDPOINTS.search, async (req, res, next) => {
+    // TODO: implement proper result scoring weighted by quality, popularity and maintenance query parameters
+    // eslint-disable-next-line prefer-const
+    let [text, size, from /* , quality, popularity, maintenance */] = ['text', 'size', 'from' /* , 'quality', 'popularity', 'maintenance' */].map(k => req.query[k]);
+    size = parseInt(size) || 20;
+    from = parseInt(from) || 0;
+    const isInteresting = compileTextSearch(text);
+    const resultStream = storage.search(0, {
+      req
+    });
+    let resultBuf = [];
+    let completed = false;
+    resultStream.on('data', pkg => {
+      // packages from the upstreams
+      if (_lodash.default.isArray(pkg)) {
+        resultBuf = resultBuf.concat(pkg.filter(pkgItem => {
+          if (!isInteresting(pkgItem?.package)) {
+            return;
+          }
+          _logger.logger.debug(`[remote] pkg name ${pkgItem?.package?.name}`);
+          return true;
+        }));
+      } else {
+        // packages from local
+        // due compability with `/-/all` we cannot refactor storage.search();
+        if (!isInteresting(pkg)) {
+          return;
+        }
+        _logger.logger.debug(`[local] pkg name ${pkg?.name}`);
+        resultBuf.push(pkg);
+      }
+    });
+    resultStream.on('error', function () {
+      _logger.logger.error('search endpoint has failed');
+      res.socket.destroy();
+    });
+    resultStream.on('end', async () => {
+      if (!completed) {
+        completed = true;
+        try {
+          const response = await sendResponse(resultBuf, resultStream, auth, req, from, size);
+          // @ts-expect-error
+          _logger.logger.info('search endpoint ok results @{total}', {
+            total: response.total
+          });
+          res.status(_constants.HTTP_STATUS.OK).json(response);
+        } catch (err) {
+          // @ts-expect-error
+          _logger.logger.error('search endpoint has failed @{err}', {
+            err
+          });
+          next(err);
+        }
+      }
+    });
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_lodash","_interopRequireDefault","require","_semver","_middleware","_constants","_logger","e","__esModule","default","personMatch","person","search","includes","field","Object","values","matcher","query","match","pkg","author","map","k","filter","x","undefined","some","txt","compileTextSearch","textSearch","textMatchers","split","every","m","removeDuplicates","results","pkgNames","package","name","push","checkAccess","auth","remoteUser","Promise","resolve","reject","allow_access","packageName","err","allowed","status","String","sendResponse","resultBuf","resultStream","req","from","size","destroy","resultsCollection","flags","unstable","keys","versions","v","semver","satisfies","local","score","final","detail","quality","popularity","maintenance","searchScore","checkAccessPromises","all","pkgItem","remote_user","i","_","isNull","slice","logger","debug","length","response","objects","total","time","Date","toUTCString","_default","route","storage","get","SEARCH_API_ENDPOINTS","res","next","text","parseInt","isInteresting","completed","on","isArray","concat","error","socket","info","HTTP_STATUS","OK","json"],"sources":["../../../../../src/api/endpoint/api/v1/search.ts"],"sourcesContent":["import _ from 'lodash';\nimport semver from 'semver';\n\nimport { SEARCH_API_ENDPOINTS } from '@verdaccio/middleware';\nimport type { Manifest } from '@verdaccio/types';\n\nimport { HTTP_STATUS } from '../../../../lib/constants';\nimport { logger } from '../../../../lib/logger';\n\ntype PublisherMaintainer = {\n  username: string;\n  email: string;\n};\n\ntype PackageResults = {\n  name: string;\n  scope: string;\n  version: string;\n  description: string;\n  date: string;\n  links: {\n    npm: string;\n    homepage?: string;\n    repository?: string;\n    bugs?: string;\n  };\n  author: { name: string };\n  publisher: PublisherMaintainer;\n  maintainer: PublisherMaintainer;\n};\n\ntype SearchResult = {\n  package: PackageResults;\n  flags?: { unstable: boolean | void };\n  local?: boolean;\n  score: {\n    final: number;\n    detail: {\n      quality: number;\n      popularity: number;\n      maintenance: number;\n    };\n  };\n  searchScore: number;\n};\n\ntype SearchResults = {\n  objects: SearchResult[];\n  total: number;\n  time: string;\n};\n\nconst personMatch = (person, search) => {\n  if (typeof person === 'string') {\n    return person.includes(search);\n  }\n\n  if (typeof person === 'object') {\n    for (const field of Object.values(person)) {\n      if (typeof field === 'string' && field.includes(search)) {\n        return true;\n      }\n    }\n  }\n\n  return false;\n};\n\nconst matcher = function (query) {\n  const match = query.match(/author:(.*)/);\n  if (match !== null) {\n    return function (pkg) {\n      return personMatch(pkg.author, match[1]);\n    };\n  }\n\n  // TODO: maintainer, keywords, boost-exact\n  // TODO implement some scoring system for freetext\n  return (pkg) => {\n    return ['name', 'displayName', 'description']\n      .map((k) => {\n        return pkg[k];\n      })\n      .filter((x) => {\n        return x !== undefined;\n      })\n      .some((txt) => {\n        return txt.includes(query);\n      });\n  };\n};\n\nfunction compileTextSearch(textSearch: string): (pkg: PackageResults) => boolean {\n  const textMatchers = (textSearch || '').split(' ').map(matcher);\n  return (pkg) => textMatchers.every((m) => m(pkg));\n}\n\nfunction removeDuplicates(results) {\n  const pkgNames: any[] = [];\n  return results.filter((pkg) => {\n    if (pkgNames.includes(pkg?.package?.name)) {\n      return false;\n    }\n    pkgNames.push(pkg?.package?.name);\n    return true;\n  });\n}\n\nfunction checkAccess(pkg: any, auth: any, remoteUser): Promise<Manifest | null> {\n  return new Promise((resolve, reject) => {\n    auth.allow_access({ packageName: pkg?.package?.name }, remoteUser, function (err, allowed) {\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          return resolve(null);\n        } else {\n          reject(err);\n        }\n      } else {\n        return resolve(allowed ? pkg : null);\n      }\n    });\n  });\n}\n\nasync function sendResponse(\n  resultBuf,\n  resultStream,\n  auth,\n  req,\n  from: number,\n  size: number\n): Promise<SearchResults> {\n  resultStream.destroy();\n  const resultsCollection = resultBuf.map((pkg): SearchResult => {\n    if (pkg?.name) {\n      return {\n        package: pkg,\n        // not sure if flags is need it\n        flags: {\n          unstable: Object.keys(pkg.versions).some((v) => semver.satisfies(v, '^1.0.0'))\n            ? undefined\n            : true,\n        },\n        local: true,\n        score: {\n          final: 1,\n          detail: {\n            quality: 1,\n            popularity: 1,\n            maintenance: 0,\n          },\n        },\n        searchScore: 100000,\n      };\n    } else {\n      return pkg;\n    }\n  });\n  const checkAccessPromises: SearchResult[] = await Promise.all(\n    removeDuplicates(resultsCollection).map((pkgItem) => {\n      return checkAccess(pkgItem, auth, req.remote_user);\n    })\n  );\n\n  const final: SearchResult[] = checkAccessPromises.filter((i) => !_.isNull(i)).slice(from, size);\n  logger.debug(`search results ${final?.length}`);\n\n  const response: SearchResults = {\n    objects: final,\n    total: final.length,\n    time: new Date().toUTCString(),\n  };\n\n  logger.debug(`total response ${final.length}`);\n  return response;\n}\n\n/**\n * Endpoint for npm search v1\n * req: 'GET /-/v1/search?text=react&size=20&from=0&quality=0.65&popularity=0.98&maintenance=0.5'\n */\nexport default function (route, auth, storage): void {\n  route.get(SEARCH_API_ENDPOINTS.search, async (req, res, next) => {\n    // TODO: implement proper result scoring weighted by quality, popularity and maintenance query parameters\n    // eslint-disable-next-line prefer-const\n    let [text, size, from /* , quality, popularity, maintenance */] = [\n      'text',\n      'size',\n      'from' /* , 'quality', 'popularity', 'maintenance' */,\n    ].map((k) => req.query[k]);\n\n    size = parseInt(size) || 20;\n    from = parseInt(from) || 0;\n\n    const isInteresting = compileTextSearch(text);\n\n    const resultStream = storage.search(0, { req });\n    let resultBuf = [] as any;\n    let completed = false;\n\n    resultStream.on('data', (pkg: SearchResult[] | PackageResults) => {\n      // packages from the upstreams\n      if (_.isArray(pkg)) {\n        resultBuf = resultBuf.concat(\n          (pkg as SearchResult[]).filter((pkgItem) => {\n            if (!isInteresting(pkgItem?.package)) {\n              return;\n            }\n            logger.debug(`[remote] pkg name ${pkgItem?.package?.name}`);\n            return true;\n          })\n        );\n      } else {\n        // packages from local\n        // due compability with `/-/all` we cannot refactor storage.search();\n        if (!isInteresting(pkg)) {\n          return;\n        }\n        logger.debug(`[local] pkg name ${(pkg as PackageResults)?.name}`);\n        resultBuf.push(pkg);\n      }\n    });\n\n    resultStream.on('error', function () {\n      logger.error('search endpoint has failed');\n      res.socket.destroy();\n    });\n\n    resultStream.on('end', async () => {\n      if (!completed) {\n        completed = true;\n        try {\n          const response = await sendResponse(resultBuf, resultStream, auth, req, from, size);\n          // @ts-expect-error\n          logger.info('search endpoint ok results @{total}', { total: response.total });\n          res.status(HTTP_STATUS.OK).json(response);\n        } catch (err) {\n          // @ts-expect-error\n          logger.error('search endpoint has failed @{err}', { err });\n          next(err);\n        }\n      }\n    });\n  });\n}\n"],"mappings":"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","ignoreList":[]}

package/build/api/endpoint/api/v1/token.js

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _debug = _interopRequireDefault(require("debug"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _auth = require("@verdaccio/auth");
+var _core = require("@verdaccio/core");
+var _middleware = require("@verdaccio/middleware");
+var _constants = require("../../../../lib/constants");
+var _logger = require("../../../../lib/logger");
+var _utils = require("../../../../lib/utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const debug = (0, _debug.default)('verdaccio:token');
+function normalizeToken(token) {
+  return {
+    ...token,
+    created: new Date(token.created).toISOString()
+  };
+}
+
+// https://github.com/npm/npm-profile/blob/latest/lib/index.js
+function _default(router, auth, storage, config) {
+  router.get('/-/npm/v1/tokens', (0, _middleware.rateLimit)(config?.userRateLimit), async function (req, res, next) {
+    const {
+      name
+    } = req.remote_user;
+    if (_lodash.default.isNil(name) === false) {
+      try {
+        const tokens = await storage.readTokens({
+          user: name
+        });
+        const totalTokens = tokens.length;
+        debug('token list retrieved: %o', totalTokens);
+        res.status(_constants.HTTP_STATUS.OK);
+        return next({
+          objects: tokens.map(normalizeToken),
+          urls: {
+            next: '' // TODO: pagination?
+          }
+        });
+      } catch (error) {
+        _logger.logger.error({
+          error: error.msg
+        }, 'token list has failed: @{error}');
+        return next(_utils.ErrorCode.getCode(_constants.HTTP_STATUS.INTERNAL_ERROR, error.message));
+      }
+    }
+    return next(_utils.ErrorCode.getUnauthorized());
+  });
+  router.post('/-/npm/v1/tokens', (0, _middleware.rateLimit)(config?.userRateLimit), function (req, res, next) {
+    const {
+      password,
+      readonly,
+      cidr_whitelist
+    } = req.body;
+    const {
+      name
+    } = req.remote_user;
+    if (!_lodash.default.isBoolean(readonly) || !_lodash.default.isArray(cidr_whitelist)) {
+      return next(_utils.ErrorCode.getCode(_constants.HTTP_STATUS.BAD_DATA, _constants.SUPPORT_ERRORS.PARAMETERS_NOT_VALID));
+    }
+    auth.authenticate(name, password, async (err, user) => {
+      if (err) {
+        const errorCode = err.message ? _constants.HTTP_STATUS.UNAUTHORIZED : _constants.HTTP_STATUS.INTERNAL_ERROR;
+        return next(_utils.ErrorCode.getCode(errorCode, err.message));
+      }
+      req.remote_user = user;
+      if (!_lodash.default.isFunction(storage.saveToken)) {
+        return next(_utils.ErrorCode.getCode(_constants.HTTP_STATUS.NOT_IMPLEMENTED, _constants.SUPPORT_ERRORS.STORAGE_NOT_IMPLEMENT));
+      }
+      try {
+        const token = await (0, _auth.getApiToken)(auth, config, user, password);
+        const key = _core.cryptoUtils.stringToMD5(token);
+        // TODO: use a utility here
+        const maskedToken = _core.cryptoUtils.mask(token, 5);
+        const created = new Date().getTime();
+
+        /**
+         * cidr_whitelist: is not being used, we pass it through
+         * token: we do not store the real token (it is generated once and retrieved to the user), just a mask of it.
+         */
+        const saveToken = {
+          user: name,
+          token: maskedToken,
+          key,
+          cidr: cidr_whitelist,
+          readonly,
+          created
+        };
+        await storage.saveToken(saveToken);
+        debug('token %o was created for user %o', key, name);
+        res.set(_constants.HEADERS.CACHE_CONTROL, 'no-cache, no-store');
+        return next(normalizeToken({
+          token,
+          user: name,
+          key: saveToken.key,
+          cidr: cidr_whitelist,
+          readonly,
+          created: saveToken.created
+        }));
+      } catch (error) {
+        _logger.logger.error({
+          error: error.msg
+        }, 'token creation has failed: @{error}');
+        return next(_utils.ErrorCode.getCode(_constants.HTTP_STATUS.INTERNAL_ERROR, error.message));
+      }
+    });
+  });
+  router.delete('/-/npm/v1/tokens/token/:tokenKey', (0, _middleware.rateLimit)(config?.userRateLimit), async (req, res, next) => {
+    const {
+      params: {
+        tokenKey
+      }
+    } = req;
+    const {
+      name
+    } = req.remote_user;
+    if (_lodash.default.isNil(name) === false) {
+      debug('%o has requested remove a token', name);
+      try {
+        await storage.deleteToken(name, tokenKey);
+        _logger.logger.info({
+          tokenKey,
+          name
+        }, 'token id @{tokenKey} was revoked for user @{name}');
+        return next({});
+      } catch (error) {
+        _logger.logger.error({
+          error: error.msg
+        }, 'token creation has failed: @{error}');
+        return next(_utils.ErrorCode.getCode(_constants.HTTP_STATUS.INTERNAL_ERROR, error.message));
+      }
+    }
+    return next(_utils.ErrorCode.getUnauthorized());
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_debug","_interopRequireDefault","require","_lodash","_auth","_core","_middleware","_constants","_logger","_utils","e","__esModule","default","debug","buildDebug","normalizeToken","token","created","Date","toISOString","_default","router","auth","storage","config","get","rateLimit","userRateLimit","req","res","next","name","remote_user","_","isNil","tokens","readTokens","user","totalTokens","length","status","HTTP_STATUS","OK","objects","map","urls","error","logger","msg","ErrorCode","getCode","INTERNAL_ERROR","message","getUnauthorized","post","password","readonly","cidr_whitelist","body","isBoolean","isArray","BAD_DATA","SUPPORT_ERRORS","PARAMETERS_NOT_VALID","authenticate","err","errorCode","UNAUTHORIZED","isFunction","saveToken","NOT_IMPLEMENTED","STORAGE_NOT_IMPLEMENT","getApiToken","key","cryptoUtils","stringToMD5","maskedToken","mask","getTime","cidr","set","HEADERS","CACHE_CONTROL","delete","params","tokenKey","deleteToken","info"],"sources":["../../../../../src/api/endpoint/api/v1/token.ts"],"sourcesContent":["import buildDebug from 'debug';\nimport type { Response, Router } from 'express';\nimport _ from 'lodash';\n\nimport { getApiToken } from '@verdaccio/auth';\nimport type { Auth } from '@verdaccio/auth';\nimport { cryptoUtils } from '@verdaccio/core';\nimport { rateLimit } from '@verdaccio/middleware';\nimport type { Config, RemoteUser, Token } from '@verdaccio/types';\n\nimport { HEADERS, HTTP_STATUS, SUPPORT_ERRORS } from '../../../../lib/constants';\nimport { logger } from '../../../../lib/logger';\nimport type Storage from '../../../../lib/storage';\nimport { ErrorCode } from '../../../../lib/utils';\nimport type { $NextFunctionVer, $RequestExtend } from '../../../../types';\n\nconst debug = buildDebug('verdaccio:token');\nexport type NormalizeToken = Token & {\n  created: string;\n};\n\nfunction normalizeToken(token: Token): NormalizeToken {\n  return {\n    ...token,\n    created: new Date(token.created).toISOString(),\n  };\n}\n\n// https://github.com/npm/npm-profile/blob/latest/lib/index.js\nexport default function (router: Router, auth: Auth, storage: Storage, config: Config) {\n  router.get(\n    '/-/npm/v1/tokens',\n    rateLimit(config?.userRateLimit),\n    async function (req: $RequestExtend, res: Response, next: $NextFunctionVer) {\n      const { name } = req.remote_user;\n\n      if (_.isNil(name) === false) {\n        try {\n          const tokens = await storage.readTokens({ user: name });\n          const totalTokens = tokens.length;\n          debug('token list retrieved: %o', totalTokens);\n          res.status(HTTP_STATUS.OK);\n          return next({\n            objects: tokens.map(normalizeToken),\n            urls: {\n              next: '', // TODO: pagination?\n            },\n          });\n        } catch (error: any) {\n          logger.error({ error: error.msg }, 'token list has failed: @{error}');\n          return next(ErrorCode.getCode(HTTP_STATUS.INTERNAL_ERROR, error.message));\n        }\n      }\n      return next(ErrorCode.getUnauthorized());\n    }\n  );\n\n  router.post(\n    '/-/npm/v1/tokens',\n    rateLimit(config?.userRateLimit),\n    function (req: $RequestExtend, res: Response, next: $NextFunctionVer) {\n      const { password, readonly, cidr_whitelist } = req.body;\n      const { name } = req.remote_user;\n\n      if (!_.isBoolean(readonly) || !_.isArray(cidr_whitelist)) {\n        return next(ErrorCode.getCode(HTTP_STATUS.BAD_DATA, SUPPORT_ERRORS.PARAMETERS_NOT_VALID));\n      }\n\n      auth.authenticate(name, password, async (err, user?: RemoteUser) => {\n        if (err) {\n          const errorCode = err.message ? HTTP_STATUS.UNAUTHORIZED : HTTP_STATUS.INTERNAL_ERROR;\n          return next(ErrorCode.getCode(errorCode, err.message));\n        }\n\n        req.remote_user = user;\n\n        if (!_.isFunction(storage.saveToken)) {\n          return next(\n            ErrorCode.getCode(HTTP_STATUS.NOT_IMPLEMENTED, SUPPORT_ERRORS.STORAGE_NOT_IMPLEMENT)\n          );\n        }\n\n        try {\n          const token = (await getApiToken(auth, config, user as RemoteUser, password)) as string;\n          const key = cryptoUtils.stringToMD5(token as string);\n          // TODO: use a utility here\n          const maskedToken = cryptoUtils.mask(token as string, 5);\n          const created = new Date().getTime();\n\n          /**\n           * cidr_whitelist: is not being used, we pass it through\n           * token: we do not store the real token (it is generated once and retrieved to the user), just a mask of it.\n           */\n          const saveToken: Token = {\n            user: name,\n            token: maskedToken,\n            key,\n            cidr: cidr_whitelist,\n            readonly,\n            created,\n          };\n\n          await storage.saveToken(saveToken);\n          debug('token %o was created for user %o', key, name);\n          res.set(HEADERS.CACHE_CONTROL, 'no-cache, no-store');\n          return next(\n            normalizeToken({\n              token,\n              user: name,\n              key: saveToken.key,\n              cidr: cidr_whitelist,\n              readonly,\n              created: saveToken.created,\n            })\n          );\n        } catch (error: any) {\n          logger.error({ error: error.msg }, 'token creation has failed: @{error}');\n          return next(ErrorCode.getCode(HTTP_STATUS.INTERNAL_ERROR, error.message));\n        }\n      });\n    }\n  );\n\n  router.delete(\n    '/-/npm/v1/tokens/token/:tokenKey',\n    rateLimit(config?.userRateLimit),\n    async (req: $RequestExtend, res: Response, next: $NextFunctionVer) => {\n      const {\n        params: { tokenKey },\n      } = req;\n      const { name } = req.remote_user;\n\n      if (_.isNil(name) === false) {\n        debug('%o has requested remove a token', name);\n        try {\n          await storage.deleteToken(name, tokenKey);\n          logger.info({ tokenKey, name }, 'token id @{tokenKey} was revoked for user @{name}');\n          return next({});\n        } catch (error: any) {\n          logger.error({ error: error.msg }, 'token creation has failed: @{error}');\n          return next(ErrorCode.getCode(HTTP_STATUS.INTERNAL_ERROR, error.message));\n        }\n      }\n      return next(ErrorCode.getUnauthorized());\n    }\n  );\n}\n"],"mappings":"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","ignoreList":[]}

package/build/api/endpoint/api/whoami.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _middleware = require("@verdaccio/middleware");
+function _default(route) {
+  route.get(_middleware.USER_API_ENDPOINTS.whoami, (req, res, next) => {
+    next({
+      username: req.remote_user.name
+    });
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfbWlkZGxld2FyZSIsInJlcXVpcmUiLCJfZGVmYXVsdCIsInJvdXRlIiwiZ2V0IiwiVVNFUl9BUElfRU5EUE9JTlRTIiwid2hvYW1pIiwicmVxIiwicmVzIiwibmV4dCIsInVzZXJuYW1lIiwicmVtb3RlX3VzZXIiLCJuYW1lIl0sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2FwaS9lbmRwb2ludC9hcGkvd2hvYW1pLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgUmVzcG9uc2UsIFJvdXRlciB9IGZyb20gJ2V4cHJlc3MnO1xuXG5pbXBvcnQgeyBVU0VSX0FQSV9FTkRQT0lOVFMgfSBmcm9tICdAdmVyZGFjY2lvL21pZGRsZXdhcmUnO1xuXG5pbXBvcnQgdHlwZSB7ICROZXh0RnVuY3Rpb25WZXIsICRSZXF1ZXN0RXh0ZW5kIH0gZnJvbSAnLi4vLi4vLi4vdHlwZXMnO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiAocm91dGU6IFJvdXRlcik6IHZvaWQge1xuICByb3V0ZS5nZXQoXG4gICAgVVNFUl9BUElfRU5EUE9JTlRTLndob2FtaSxcbiAgICAocmVxOiAkUmVxdWVzdEV4dGVuZCwgcmVzOiBSZXNwb25zZSwgbmV4dDogJE5leHRGdW5jdGlvblZlcik6IGFueSA9PiB7XG4gICAgICBuZXh0KHsgdXNlcm5hbWU6IHJlcS5yZW1vdGVfdXNlci5uYW1lIH0pO1xuICAgIH1cbiAgKTtcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBRUEsSUFBQUEsV0FBQSxHQUFBQyxPQUFBO0FBSWUsU0FBQUMsU0FBVUMsS0FBYSxFQUFRO0VBQzVDQSxLQUFLLENBQUNDLEdBQUcsQ0FDUEMsOEJBQWtCLENBQUNDLE1BQU0sRUFDekIsQ0FBQ0MsR0FBbUIsRUFBRUMsR0FBYSxFQUFFQyxJQUFzQixLQUFVO0lBQ25FQSxJQUFJLENBQUM7TUFBRUMsUUFBUSxFQUFFSCxHQUFHLENBQUNJLFdBQVcsQ0FBQ0M7SUFBSyxDQUFDLENBQUM7RUFDMUMsQ0FDRixDQUFDO0FBQ0giLCJpZ25vcmVMaXN0IjpbXX0=