@verdaccio/api 6.0.0-6-next.12 → 6.0.0-6-next.16

package/src/package.ts

@@ -3,11 +3,11 @@ import { Router } from 'express';
 import buildDebug from 'debug';
 
 import { allow } from '@verdaccio/middleware';
-import { getVersion, ErrorCode } from '@verdaccio/utils';
-import { HEADERS, DIST_TAGS, API_ERROR } from '@verdaccio/commons-api';
+import { getVersion } from '@verdaccio/utils';
+import { HEADERS, DIST_TAGS, API_ERROR, errorUtils } from '@verdaccio/core';
 import { Config, Package } from '@verdaccio/types';
 import { IAuth } from '@verdaccio/auth';
-import { IStorageHandler } from '@verdaccio/store';
+import { Storage } from '@verdaccio/store';
 import { convertDistRemoteToLocalTarballUrls } from '@verdaccio/tarball';
 import { $RequestExtend, $ResponseExtend, $NextFunctionVer } from '../types/custom';
 
@@ -34,12 +34,7 @@ const downloadStream = (
   stream.pipe(res);
 };
 
-export default function (
-  route: Router,
-  auth: IAuth,
-  storage: IStorageHandler,
-  config: Config
-): void {
+export default function (route: Router, auth: IAuth, storage: Storage, config: Config): void {
   const can = allow(auth);
   // TODO: anonymous user?
   route.get(
@@ -85,7 +80,7 @@ export default function (
         }
 
         debug('package version not found %o', queryVersion);
-        return next(ErrorCode.getNotFound(`${API_ERROR.VERSION_NOT_EXIST}: ${queryVersion}`));
+        return next(errorUtils.getNotFound(`${API_ERROR.VERSION_NOT_EXIST}: ${queryVersion}`));
       };
 
       debug('get package name %o', name);

package/src/publish.ts

@@ -4,14 +4,21 @@ import mime from 'mime';
 import { Router } from 'express';
 import buildDebug from 'debug';
 
-import { API_MESSAGE, HEADERS, DIST_TAGS, API_ERROR, HTTP_STATUS } from '@verdaccio/commons-api';
-import { validateMetadata, isObject, ErrorCode, hasDiffOneKey } from '@verdaccio/utils';
+import {
+  API_MESSAGE,
+  HEADERS,
+  DIST_TAGS,
+  API_ERROR,
+  HTTP_STATUS,
+  errorUtils,
+} from '@verdaccio/core';
+import { validateMetadata, isObject, hasDiffOneKey } from '@verdaccio/utils';
 import { media, expectJson, allow } from '@verdaccio/middleware';
 import { notify } from '@verdaccio/hooks';
-import { Config, Callback, MergeTags, Version, Package } from '@verdaccio/types';
+import { Config, Callback, MergeTags, Version, Package, CallbackAction } from '@verdaccio/types';
 import { logger } from '@verdaccio/logger';
 import { IAuth } from '@verdaccio/auth';
-import { IStorageHandler } from '@verdaccio/store';
+import { Storage } from '@verdaccio/store';
 import { $RequestExtend, $ResponseExtend, $NextFunctionVer } from '../types/custom';
 
 import star from './star';
@@ -22,7 +29,7 @@ const debug = buildDebug('verdaccio:api:publish');
 export default function publish(
   router: Router,
   auth: IAuth,
-  storage: IStorageHandler,
+  storage: Storage,
   config: Config
 ): void {
   const can = allow(auth);
@@ -138,7 +145,7 @@ export default function publish(
 /**
  * Publish a package
  */
-export function publishPackage(storage: IStorageHandler, config: Config, auth: IAuth): any {
+export function publishPackage(storage: Storage, config: Config, auth: IAuth): any {
   const starApi = star(storage);
   return function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer): void {
     const packageName = req.params.package;
@@ -172,7 +179,7 @@ export function publishPackage(storage: IStorageHandler, config: Config, auth: I
     /**
      * Add new package version in storage
      */
-    const createVersion = function (version: string, metadata: Version, cb: Callback): void {
+    const createVersion = function (version: string, metadata: Version, cb: CallbackAction): void {
       debug('add a new package version %o to storage %o', version, metadata);
       storage.addVersion(packageName, version, metadata, null, cb);
     };
@@ -180,7 +187,7 @@ export function publishPackage(storage: IStorageHandler, config: Config, auth: I
     /**
      * Add new tags in storage
      */
-    const addTags = function (tags: MergeTags, cb: Callback): void {
+    const addTags = function (tags: MergeTags, cb: CallbackAction): void {
       debug('add new tag %o to storage', packageName);
       storage.mergeTags(packageName, tags, cb);
     };
@@ -224,7 +231,7 @@ export function publishPackage(storage: IStorageHandler, config: Config, auth: I
         // if this happens in normal circumstances, report it as a bug
         debug('invalid body format');
         logger.info({ packageName }, `wrong package format on publish a package @{packageName}`);
-        return next(ErrorCode.getBadRequest(API_ERROR.UNSUPORTED_REGISTRY_CALL));
+        return next(errorUtils.getBadRequest(API_ERROR.UNSUPORTED_REGISTRY_CALL));
       }
 
       if (error && error.status !== HTTP_STATUS.CONFLICT) {
@@ -322,7 +329,7 @@ export function publishPackage(storage: IStorageHandler, config: Config, auth: I
     } catch (error: any) {
       debug('error on publish, bad package format %o', packageName);
       logger.error({ packageName }, 'error on publish, bad package data for @{packageName}');
-      return next(ErrorCode.getBadData(API_ERROR.BAD_PACKAGE_DATA));
+      return next(errorUtils.getBadData(API_ERROR.BAD_PACKAGE_DATA));
     }
   };
 }
@@ -330,25 +337,27 @@ export function publishPackage(storage: IStorageHandler, config: Config, auth: I
 /**
  * un-publish a package
  */
-export function unPublishPackage(storage: IStorageHandler) {
-  return function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer): void {
+export function unPublishPackage(storage: Storage) {
+  return async function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer) {
     const packageName = req.params.package;
 
     logger.debug({ packageName }, `unpublishing @{packageName}`);
-    storage.removePackage(packageName, function (err) {
+    try {
+      await storage.removePackage(packageName);
+    } catch (err) {
       if (err) {
         return next(err);
       }
-      res.status(HTTP_STATUS.CREATED);
-      return next({ ok: API_MESSAGE.PKG_REMOVED });
-    });
+    }
+    res.status(HTTP_STATUS.CREATED);
+    return next({ ok: API_MESSAGE.PKG_REMOVED });
   };
 }
 
 /**
  * Delete tarball
  */
-export function removeTarball(storage: IStorageHandler) {
+export function removeTarball(storage: Storage) {
   return function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer): void {
     const packageName = req.params.package;
     const { filename, revision } = req.params;
@@ -374,7 +383,7 @@ export function removeTarball(storage: IStorageHandler) {
 /**
  * Adds a new version
  */
-export function addVersion(storage: IStorageHandler) {
+export function addVersion(storage: Storage) {
   return function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer): void {
     const { version, tag } = req.params;
     const packageName = req.params.package;
@@ -398,7 +407,7 @@ export function addVersion(storage: IStorageHandler) {
 /**
  * uploadPackageTarball
  */
-export function uploadPackageTarball(storage: IStorageHandler) {
+export function uploadPackageTarball(storage: Storage) {
   return function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer): void {
     const packageName = req.params.package;
     const stream = storage.addTarball(packageName, req.params.filename);

package/src/search.ts

@@ -1,102 +1,11 @@
-import { HEADERS } from '@verdaccio/commons-api';
-
-export default function (route, auth, storage): void {
-  // searching packages
-  route.get('/-/all(/since)?', function (req, res) {
-    let received_end = false;
-    let response_finished = false;
-    let processing_pkgs = 0;
-    let firstPackage = true;
-
-    res.status(200);
-    res.set(HEADERS.CONTENT_TYPE, 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 (): void {
-      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 () {
-      res.socket.destroy();
-    });
-
-    stream.on('end', function () {
-      received_end = true;
-      check_finish();
-    });
+import { HTTP_STATUS } from '@verdaccio/core';
+import { logger } from '@verdaccio/logger';
+
+export default function (route): void {
+  // TODO: next major version, remove this
+  route.get('/-/all(/since)?', function (_req, res) {
+    logger.warn('search endpoint has been removed, please use search v1');
+    res.status(HTTP_STATUS.NOT_FOUND);
+    res.json({ error: 'not found, endpoint was removed' });
   });
 }

package/src/star.ts

@@ -1,15 +1,15 @@
-import { USERS, HTTP_STATUS } from '@verdaccio/commons-api';
+import { USERS, HTTP_STATUS } from '@verdaccio/core';
 import { Response } from 'express';
 import _ from 'lodash';
 import buildDebug from 'debug';
 
-import { IStorageHandler } from '@verdaccio/store';
+import { Storage } from '@verdaccio/store';
 import { $RequestExtend, $NextFunctionVer } from '../types/custom';
 
 const debug = buildDebug('verdaccio:api:publish:star');
 
 export default function (
-  storage: IStorageHandler
+  storage: Storage
 ): (req: $RequestExtend, res: Response, next: $NextFunctionVer) => void {
   const validateInputs = (newUsers, localUsers, username, isStar): boolean => {
     const isExistlocalUsers = _.isNil(localUsers[username]) === false;
@@ -40,6 +40,7 @@ export default function (
     };
 
     debug('get package info package for %o', name);
+    // @ts-ignore
     storage.getPackage({
       name,
       req,

package/src/stars.ts

@@ -1,15 +1,15 @@
 import _ from 'lodash';
 import { Response, Router } from 'express';
 
-import { USERS, HTTP_STATUS } from '@verdaccio/commons-api';
+import { USERS, HTTP_STATUS } from '@verdaccio/core';
 import { Package } from '@verdaccio/types';
 
-import { IStorageHandler } from '@verdaccio/store';
+import { Storage } from '@verdaccio/store';
 import { $RequestExtend, $NextFunctionVer } from '../types/custom';
 
 type Packages = Package[];
 
-export default function (route: Router, storage: IStorageHandler): void {
+export default function (route: Router, storage: Storage): void {
   route.get(
     '/-/_view/starredByUser',
     (req: $RequestExtend, res: Response, next: $NextFunctionVer): void => {

package/src/user.ts

@@ -2,14 +2,14 @@ import _ from 'lodash';
 import { Response, Router } from 'express';
 import buildDebug from 'debug';
 
-import { getAuthenticatedMessage, validatePassword, ErrorCode } from '@verdaccio/utils';
+import { getAuthenticatedMessage, validatePassword } from '@verdaccio/utils';
 import { getApiToken } from '@verdaccio/auth';
 import { logger } from '@verdaccio/logger';
 import { createRemoteUser } from '@verdaccio/config';
 
 import { Config, RemoteUser } from '@verdaccio/types';
 import { IAuth } from '@verdaccio/auth';
-import { API_ERROR, API_MESSAGE, HTTP_STATUS } from '@verdaccio/commons-api';
+import { API_ERROR, API_MESSAGE, HTTP_STATUS, errorUtils } from '@verdaccio/core';
 import { $RequestExtend, $NextFunctionVer } from '../types/custom';
 
 const debug = buildDebug('verdaccio:api:user');
@@ -47,7 +47,7 @@ export default function (route: Router, auth: IAuth, config: Config): void {
                 'authenticating for user @{username} failed. Error: @{err.message}'
               );
               return next(
-                ErrorCode.getCode(HTTP_STATUS.UNAUTHORIZED, API_ERROR.BAD_USERNAME_PASSWORD)
+                errorUtils.getCode(HTTP_STATUS.UNAUTHORIZED, API_ERROR.BAD_USERNAME_PASSWORD)
               );
             }
 
@@ -55,7 +55,7 @@ export default function (route: Router, auth: IAuth, config: Config): void {
             const token = await getApiToken(auth, config, restoredRemoteUser, password);
             debug('login: new token');
             if (!token) {
-              return next(ErrorCode.getUnauthorized());
+              return next(errorUtils.getUnauthorized());
             }
 
             res.status(HTTP_STATUS.CREATED);
@@ -73,7 +73,7 @@ export default function (route: Router, auth: IAuth, config: Config): void {
         if (validatePassword(password) === false) {
           debug('adduser: invalid password');
           // eslint-disable-next-line new-cap
-          return next(ErrorCode.getCode(HTTP_STATUS.BAD_REQUEST, API_ERROR.PASSWORD_SHORT()));
+          return next(errorUtils.getCode(HTTP_STATUS.BAD_REQUEST, API_ERROR.PASSWORD_SHORT()));
         }
 
         auth.add_user(name, password, async function (err, user): Promise<void> {
@@ -84,7 +84,7 @@ export default function (route: Router, auth: IAuth, config: Config): void {
               // and npm accepts only an 409 error.
               // So, changing status code here.
               return next(
-                ErrorCode.getCode(err.status, err.message) || ErrorCode.getConflict(err.message)
+                errorUtils.getCode(err.status, err.message) || errorUtils.getConflict(err.message)
               );
             }
             return next(err);
@@ -94,7 +94,7 @@ export default function (route: Router, auth: IAuth, config: Config): void {
             name && password ? await getApiToken(auth, config, user, password) : undefined;
           debug('adduser: new token %o', token);
           if (!token) {
-            return next(ErrorCode.getUnauthorized());
+            return next(errorUtils.getUnauthorized());
           }
 
           req.remote_user = user;

package/src/v1/profile.ts

@@ -1,8 +1,8 @@
 import _ from 'lodash';
 import { Response, Router } from 'express';
 
-import { API_ERROR, APP_ERROR, HTTP_STATUS, SUPPORT_ERRORS } from '@verdaccio/commons-api';
-import { ErrorCode, validatePassword } from '@verdaccio/utils';
+import { API_ERROR, APP_ERROR, HTTP_STATUS, SUPPORT_ERRORS, errorUtils } from '@verdaccio/core';
+import { validatePassword } from '@verdaccio/utils';
 import { IAuth } from '@verdaccio/auth';
 import { $RequestExtend, $NextFunctionVer } from '../../types/custom';
 
@@ -61,7 +61,7 @@ export default function (route: Router, auth: IAuth): void {
       if (_.isNil(password) === false) {
         if (validatePassword(password.new) === false) {
           /* eslint new-cap:off */
-          return next(ErrorCode.getCode(HTTP_STATUS.UNAUTHORIZED, API_ERROR.PASSWORD_SHORT()));
+          return next(errorUtils.getCode(HTTP_STATUS.UNAUTHORIZED, API_ERROR.PASSWORD_SHORT()));
           /* eslint new-cap:off */
         }
 
@@ -72,22 +72,22 @@ export default function (route: Router, auth: IAuth): void {
           (err, isUpdated): $NextFunctionVer => {
             if (_.isNull(err) === false) {
               return next(
-                ErrorCode.getCode(err.status, err.message) || ErrorCode.getConflict(err.message)
+                errorUtils.getCode(err.status, err.message) || errorUtils.getConflict(err.message)
               );
             }
 
             if (isUpdated) {
               return next(buildProfile(req.remote_user.name));
             }
-            return next(ErrorCode.getInternalError(API_ERROR.INTERNAL_SERVER_ERROR));
+            return next(errorUtils.getInternalError(API_ERROR.INTERNAL_SERVER_ERROR));
           }
         );
       } else if (_.isNil(tfa) === false) {
         return next(
-          ErrorCode.getCode(HTTP_STATUS.SERVICE_UNAVAILABLE, SUPPORT_ERRORS.TFA_DISABLED)
+          errorUtils.getCode(HTTP_STATUS.SERVICE_UNAVAILABLE, SUPPORT_ERRORS.TFA_DISABLED)
         );
       } else {
-        return next(ErrorCode.getCode(HTTP_STATUS.INTERNAL_ERROR, APP_ERROR.PROFILE_ERROR));
+        return next(errorUtils.getCode(HTTP_STATUS.INTERNAL_ERROR, APP_ERROR.PROFILE_ERROR));
       }
     }
   );

package/src/v1/search.ts

@@ -1,106 +1,81 @@
-import semver from 'semver';
+import _ from 'lodash';
+import buildDebug from 'debug';
+import { logger } from '@verdaccio/logger';
+import { IAuth } from '@verdaccio/auth';
+import { HTTP_STATUS, searchUtils } from '@verdaccio/core';
+import { Storage } from '@verdaccio/store';
 import { Package } from '@verdaccio/types';
 
-function compileTextSearch(textSearch: string): (pkg: Package) => boolean {
-  const personMatch = (person, search) => {
-    if (typeof person === 'string') {
-      return person.includes(search);
-    }
+const debug = buildDebug('verdaccio:api:search');
 
-    if (typeof person === 'object') {
-      for (const field of Object.values(person)) {
-        if (typeof field === 'string' && field.includes(search)) {
-          return true;
+/**
+ * Endpoint for npm search v1
+ * Empty value
+ *  - {"objects":[],"total":0,"time":"Sun Jul 25 2021 14:09:11 GMT+0000 (Coordinated Universal Time)"}
+ * req: 'GET /-/v1/search?text=react&size=20&frpom=0&quality=0.65&popularity=0.98&maintenance=0.5'
+ */
+export default function (route, auth: IAuth, storage: Storage): void {
+  function checkAccess(pkg: any, auth: any, remoteUser): Promise<Package | null> {
+    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);
         }
-      }
-    }
-
-    return false;
-  };
-  const matcher = function (q) {
-    const match = q.match(/author:(.*)/);
-    if (match !== null) {
-      return (pkg) => personMatch(pkg.author, match[1]);
-    }
-
-    // TODO: maintainer, keywords, not/is unstable insecure, boost-exact
-    // TODO implement some scoring system for freetext
-    return (pkg) => {
-      return ['name', 'displayName', 'description']
-        .map((k) => pkg[k])
-        .filter((x) => x !== undefined)
-        .some((txt) => txt.includes(q));
-    };
-  };
-
-  const textMatchers = (textSearch || '').split(' ').map(matcher);
-  return (pkg) => textMatchers.every((m) => m(pkg));
-}
+      });
+    });
+  }
 
-export default function (route, auth, storage): void {
-  route.get('/-/v1/search', (req, res) => {
-    // TODO: implement proper result scoring weighted by quality, popularity and
-    // maintenance query parameters
-    let [text, size, from] = [
-      'text',
-      'size',
-      'from' /* , 'quality', 'popularity', 'maintenance' */,
-    ].map((k) => req.query[k]);
+  route.get('/-/v1/search', async (req, res, next) => {
+    const { query, url } = req;
+    let [size, from] = ['size', 'from'].map((k) => query[k]);
+    let data;
+    const abort = new AbortController();
 
-    size = parseInt(size) || 20;
-    from = parseInt(from) || 0;
+    req.on('aborted', () => {
+      abort.abort();
+    });
 
-    const isInteresting = compileTextSearch(text);
+    size = parseInt(size, 10) || 20;
+    from = parseInt(from, 10) || 0;
 
-    const resultStream = storage.search(0, { req: { query: { local: true } } });
-    const resultBuf = [] as any;
-    let completed = false;
+    try {
+      data = await storage.searchManager?.search({
+        query,
+        url,
+        abort,
+      });
+      debug('stream finish');
+      const checkAccessPromises: searchUtils.SearchItemPkg[] = await Promise.all(
+        data.map((pkgItem) => {
+          return checkAccess(pkgItem, auth, req.remote_user);
+        })
+      );
 
-    const sendResponse = (): void => {
-      completed = true;
-      resultStream.destroy();
+      const final: searchUtils.SearchItemPkg[] = checkAccessPromises
+        .filter((i) => !_.isNull(i))
+        .slice(from, size);
+      logger.debug(`search results ${final?.length}`);
 
-      const final = resultBuf.slice(from, size).map((pkg) => {
-        return {
-          package: pkg,
-          flags: {
-            unstable: Object.keys(pkg.versions).some((v) => semver.satisfies(v, '^1.0.0'))
-              ? undefined
-              : true,
-          },
-          score: {
-            final: 1,
-            detail: {
-              quality: 1,
-              popularity: 1,
-              maintenance: 0,
-            },
-          },
-          searchScore: 100000,
-        };
-      });
-      const response = {
+      const response: searchUtils.SearchResults = {
         objects: final,
         total: final.length,
         time: new Date().toUTCString(),
       };
 
-      res.status(200).json(response);
-    };
-
-    resultStream.on('data', (pkg) => {
-      if (!isInteresting(pkg)) {
-        return;
-      }
-      resultBuf.push(pkg);
-      if (!completed && resultBuf.length >= size + from) {
-        sendResponse();
-      }
-    });
-    resultStream.on('end', () => {
-      if (!completed) {
-        sendResponse();
-      }
-    });
+      res.status(HTTP_STATUS.OK).json(response);
+    } catch (error) {
+      logger.error({ error }, 'search endpoint has failed @{error.message}');
+      next(next);
+      return;
+    }
   });
 }