@verdaccio/local-storage 11.0.0-6-next.7 → 11.0.0-6-next.11

package/CHANGELOG.md

@@ -1,5 +1,109 @@
 # Change Log
 
+## 11.0.0-6-next.11
+
+### Major Changes
+
+- a828271d: refactor: download manifest endpoint and integrate fastify
+
+  Much simpler API for fetching a package
+
+  ```
+   const manifest = await storage.getPackageNext({
+        name,
+        uplinksLook: true,
+        req,
+        version: queryVersion,
+        requestOptions,
+   });
+  ```
+
+  > not perfect, the `req` still is being passed to the proxy (this has to be refactored at proxy package) and then removed from here, in proxy we pass the request instance to the `request` library.
+
+  ### Details
+
+  - `async/await` sugar for getPackage()
+  - Improve and reuse code between current implementation and new fastify endpoint (add scaffolding for request manifest)
+  - Improve performance
+  - Add new tests
+
+  ### Breaking changes
+
+  All storage plugins will stop to work since the storage uses `getPackageNext` method which is Promise based, I won't replace this now because will force me to update all plugins, I'll follow up in another PR. Currently will throw http 500
+
+### Patch Changes
+
+- Updated dependencies [24b9be02]
+  - @verdaccio/core@6.0.0-6-next.4
+  - @verdaccio/file-locking@11.0.0-6-next.4
+  - @verdaccio/streams@11.0.0-6-next.5
+
+## 11.0.0-6-next.10
+
+### Patch Changes
+
+- Updated dependencies [6c1eb021]
+  - @verdaccio/core@6.0.0-6-next.3
+
+## 11.0.0-6-next.9
+
+### Minor Changes
+
+- 154b2ecd: refactor: remove @verdaccio/commons-api in favor @verdaccio/core and remove duplications
+
+### Patch Changes
+
+- Updated dependencies [794af76c]
+- Updated dependencies [154b2ecd]
+  - @verdaccio/core@6.0.0-6-next.2
+  - @verdaccio/file-locking@11.0.0-6-next.4
+  - @verdaccio/streams@11.0.0-6-next.5
+
+## 11.0.0-6-next.8
+
+### Major Changes
+
+- 459b6fa7: refactor: search v1 endpoint and local-database
+
+  - refactor search `api v1` endpoint, improve performance
+  - remove usage of `async` dependency https://github.com/verdaccio/verdaccio/issues/1225
+  - refactor method storage class
+  - create new module `core` to reduce the ammount of modules with utilities
+  - use `undici` instead `node-fetch`
+  - use `fastify` instead `express` for functional test
+
+  ### Breaking changes
+
+  - plugin storage API changes
+  - remove old search endpoint (return 404)
+  - filter local private packages at plugin level
+
+  The storage api changes for methods `get`, `add`, `remove` as promise base. The `search` methods also changes and recieves a `query` object that contains all query params from the client.
+
+  ```ts
+  export interface IPluginStorage<T> extends IPlugin {
+    add(name: string): Promise<void>;
+    remove(name: string): Promise<void>;
+    get(): Promise<any>;
+    init(): Promise<void>;
+    getSecret(): Promise<string>;
+    setSecret(secret: string): Promise<any>;
+    getPackageStorage(packageInfo: string): IPackageStorage;
+    search(query: searchUtils.SearchQuery): Promise<searchUtils.SearchItem[]>;
+    saveToken(token: Token): Promise<any>;
+    deleteToken(user: string, tokenKey: string): Promise<any>;
+    readTokens(filter: TokenFilter): Promise<Token[]>;
+  }
+  ```
+
+### Patch Changes
+
+- Updated dependencies [459b6fa7]
+  - @verdaccio/commons-api@11.0.0-6-next.4
+  - @verdaccio/core@6.0.0-6-next.1
+  - @verdaccio/streams@11.0.0-6-next.4
+  - @verdaccio/file-locking@11.0.0-alpha.3
+
 ## 11.0.0-6-next.7
 
 ### Patch Changes

package/build/dir-utils.d.ts

@@ -0,0 +1,34 @@
+import { searchUtils } from '@verdaccio/core';
+/**
+ * Retrieve a list of absolute paths to all folders in the given storage path
+ * @param storagePath the base path of the storage
+ * @return a promise that resolves to an array of absolute paths
+ */
+export declare function getFolders(storagePath: string, pattern?: string): Promise<string[]>;
+/**
+ * Search packages on the the storage. The storage could be
+ * - storage
+ *    - pkg1
+ *    - @company
+ *      - pkg2 -> @scompany/pkg2
+ *    - storage1
+ *      - pkg2
+ *      - pkg3
+ *    - storage2
+ *        - @scope
+ *           - pkg4 > @scope/pkg4
+ * The search return a data structure like:
+ *  [
+ *   {
+ *    name: 'pkg1', // package name could be @scope/pkg1
+ *    path: absolute/path/package/name
+ *   }
+ *  ]
+ * @param {string} storagePath is the base path of the storage folder,
+ * inside could be packages, storages and @scope packages.
+ * @param {Set<string>} storages storages are defined peer package access pattern via `storage` property
+ * @param query is the search query from the user via npm search command.
+ * and are intended to organize packages in a tree structure.
+ * @returns {Promise<searchUtils.SearchItemPkg[]>}
+ */
+export declare function searchOnStorage(storagePath: string, storages: Map<string, string>): Promise<searchUtils.SearchItemPkg[]>;

package/build/dir-utils.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getFolders = getFolders;
+exports.searchOnStorage = searchOnStorage;
+
+var _debug = _interopRequireDefault(require("debug"));
+
+var _globby = _interopRequireDefault(require("globby"));
+
+var _path = require("path");
+
+var _core = require("@verdaccio/core");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const debug = (0, _debug.default)('verdaccio:plugin:local-storage:utils');
+/**
+ * Retrieve a list of absolute paths to all folders in the given storage path
+ * @param storagePath the base path of the storage
+ * @return a promise that resolves to an array of absolute paths
+ */
+
+async function getFolders(storagePath, pattern = '*') {
+  // @ts-ignore - check why this fails, types are correct
+  const files = await (0, _globby.default)(pattern, {
+    // @ts-ignore
+    cwd: storagePath,
+    expandDirectories: true,
+    onlyDirectories: true,
+    onlyFiles: false,
+    // should not go deeper than the storage path (10 is reseaon for the storage))
+    deep: 10,
+    dot: false,
+    followSymbolicLinks: true,
+    caseSensitiveMatch: true,
+    unique: true // FIXME: add here list of forbiden patterns
+    // don't include scoped folders.
+    // ignore: [`@*`],
+
+  });
+  return files;
+}
+/**
+ * Search packages on the the storage. The storage could be
+ * - storage
+ *    - pkg1
+ *    - @company
+ *      - pkg2 -> @scompany/pkg2
+ *    - storage1
+ *      - pkg2
+ *      - pkg3
+ *    - storage2
+ *        - @scope
+ *           - pkg4 > @scope/pkg4
+ * The search return a data structure like:
+ *  [
+ *   {
+ *    name: 'pkg1', // package name could be @scope/pkg1
+ *    path: absolute/path/package/name
+ *   }
+ *  ]
+ * @param {string} storagePath is the base path of the storage folder,
+ * inside could be packages, storages and @scope packages.
+ * @param {Set<string>} storages storages are defined peer package access pattern via `storage` property
+ * @param query is the search query from the user via npm search command.
+ * and are intended to organize packages in a tree structure.
+ * @returns {Promise<searchUtils.SearchItemPkg[]>}
+ */
+
+
+async function searchOnStorage(storagePath, storages) {
+  const matchedStorages = Array.from(storages);
+  const storageFolders = Array.from(storages.keys()); // const getScopedFolders = async (pkgName) => {
+  //   const scopedPackages = await getFolders(join(storagePath, pkgName), '*');
+  //   const listScoped = scopedPackages.map((scoped) => ({
+  //     name: `${pkgName}/${scoped}`,
+  //   }));
+  // };
+
+  debug('search on %o', storagePath);
+  debug('storage folders %o', matchedStorages.length);
+  let results = []; // watch base path and ignore storage folders
+
+  const basePathFolders = (await getFolders(storagePath, '*')).filter(storageFolder => !storageFolders.includes(storageFolder));
+
+  for (let store of basePathFolders) {
+    if (_core.validatioUtils.isPackageNameScoped(store)) {
+      const scopedPackages = await getFolders((0, _path.join)(storagePath, store), '*');
+      const listScoped = scopedPackages.map(scoped => ({
+        name: `${store}/${scoped}`,
+        scoped: store
+      }));
+      results.push(...listScoped);
+    } else {
+      results.push({
+        name: store
+      });
+    }
+  } // iterate each storage folder
+
+
+  for (const store of storageFolders) {
+    const foldersOnStorage = await getFolders((0, _path.join)(storagePath, store), '*');
+
+    for (let pkgName of foldersOnStorage) {
+      if (_core.validatioUtils.isPackageNameScoped(pkgName)) {
+        const scopedPackages = await getFolders((0, _path.join)(storagePath, store, pkgName), '*');
+        const listScoped = scopedPackages.map(scoped => ({
+          name: `${pkgName}/${scoped}`,
+          scoped: pkgName
+        }));
+        results.push(...listScoped);
+      } else {
+        results.push({
+          name: pkgName
+        });
+      }
+    }
+  }
+
+  return results;
+}
+//# sourceMappingURL=dir-utils.js.map

package/build/dir-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/dir-utils.ts"],"names":["debug","getFolders","storagePath","pattern","files","cwd","expandDirectories","onlyDirectories","onlyFiles","deep","dot","followSymbolicLinks","caseSensitiveMatch","unique","searchOnStorage","storages","matchedStorages","Array","from","storageFolders","keys","length","results","basePathFolders","filter","storageFolder","includes","store","validatioUtils","isPackageNameScoped","scopedPackages","listScoped","map","scoped","name","push","foldersOnStorage","pkgName"],"mappings":"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","sourcesContent":["import buildDebug from 'debug';\nimport globby from 'globby';\nimport { join } from 'path';\n\nimport { searchUtils, validatioUtils } from '@verdaccio/core';\n\nconst debug = buildDebug('verdaccio:plugin:local-storage:utils');\n\n/**\n * Retrieve a list of absolute paths to all folders in the given storage path\n * @param storagePath the base path of the storage\n * @return a promise that resolves to an array of absolute paths\n */\nexport async function getFolders(storagePath: string, pattern = '*'): Promise<string[]> {\n  // @ts-ignore - check why this fails, types are correct\n  const files = await globby(pattern, {\n    // @ts-ignore\n    cwd: storagePath,\n    expandDirectories: true,\n    onlyDirectories: true,\n    onlyFiles: false,\n    // should not go deeper than the storage path (10 is reseaon for the storage))\n    deep: 10,\n    dot: false,\n    followSymbolicLinks: true,\n    caseSensitiveMatch: true,\n    unique: true,\n    // FIXME: add here list of forbiden patterns\n    // don't include scoped folders.\n    // ignore: [`@*`],\n  });\n  return files;\n}\n\n/**\n * Search packages on the the storage. The storage could be\n * - storage\n *    - pkg1\n *    - @company\n *      - pkg2 -> @scompany/pkg2\n *    - storage1\n *      - pkg2\n *      - pkg3\n *    - storage2\n *        - @scope\n *           - pkg4 > @scope/pkg4\n * The search return a data structure like:\n *  [\n *   {\n *    name: 'pkg1', // package name could be @scope/pkg1\n *    path: absolute/path/package/name\n *   }\n *  ]\n * @param {string} storagePath is the base path of the storage folder,\n * inside could be packages, storages and @scope packages.\n * @param {Set<string>} storages storages are defined peer package access pattern via `storage` property\n * @param query is the search query from the user via npm search command.\n * and are intended to organize packages in a tree structure.\n * @returns {Promise<searchUtils.SearchItemPkg[]>}\n */\nexport async function searchOnStorage(\n  storagePath: string,\n  storages: Map<string, string>\n): Promise<searchUtils.SearchItemPkg[]> {\n  const matchedStorages = Array.from(storages);\n  const storageFolders = Array.from(storages.keys());\n  // const getScopedFolders = async (pkgName) => {\n  //   const scopedPackages = await getFolders(join(storagePath, pkgName), '*');\n  //   const listScoped = scopedPackages.map((scoped) => ({\n  //     name: `${pkgName}/${scoped}`,\n  //   }));\n  // };\n  debug('search on %o', storagePath);\n  debug('storage folders %o', matchedStorages.length);\n  let results: searchUtils.SearchItemPkg[] = [];\n  // watch base path and ignore storage folders\n  const basePathFolders = (await getFolders(storagePath, '*')).filter(\n    (storageFolder) => !storageFolders.includes(storageFolder)\n  );\n\n  for (let store of basePathFolders) {\n    if (validatioUtils.isPackageNameScoped(store)) {\n      const scopedPackages = await getFolders(join(storagePath, store), '*');\n      const listScoped = scopedPackages.map((scoped) => ({\n        name: `${store}/${scoped}`,\n        scoped: store,\n      }));\n      results.push(...listScoped);\n    } else {\n      results.push({\n        name: store,\n      });\n    }\n  }\n\n  // iterate each storage folder\n  for (const store of storageFolders) {\n    const foldersOnStorage = await getFolders(join(storagePath, store), '*');\n    for (let pkgName of foldersOnStorage) {\n      if (validatioUtils.isPackageNameScoped(pkgName)) {\n        const scopedPackages = await getFolders(join(storagePath, store, pkgName), '*');\n        const listScoped = scopedPackages.map((scoped) => ({\n          name: `${pkgName}/${scoped}`,\n          scoped: pkgName,\n        }));\n        results.push(...listScoped);\n      } else {\n        results.push({\n          name: pkgName,\n        });\n      }\n    }\n  }\n\n  return results;\n}\n"],"file":"dir-utils.js"}

package/build/fs.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import fs from 'fs';
+declare const mkdirPromise: typeof fs.mkdir.__promisify__;
+declare const writeFilePromise: typeof fs.writeFile.__promisify__;
+declare const readdirPromise: typeof fs.readdir.__promisify__;
+declare const statPromise: typeof fs.stat.__promisify__;
+declare const unlinkPromise: typeof fs.unlink.__promisify__;
+declare const rmdirPromise: typeof fs.rmdir.__promisify__;
+export declare const readFilePromise: (path: any) => Promise<string>;
+export { mkdirPromise, writeFilePromise, readdirPromise, statPromise, unlinkPromise, rmdirPromise };

package/build/fs.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.writeFilePromise = exports.unlinkPromise = exports.statPromise = exports.rmdirPromise = exports.readdirPromise = exports.readFilePromise = exports.mkdirPromise = void 0;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _util = require("util");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// FUTURE: when v15 is min replace by fs/promises
+const readFile = (0, _util.promisify)(_fs.default.readFile);
+const mkdirPromise = (0, _util.promisify)(_fs.default.mkdir);
+exports.mkdirPromise = mkdirPromise;
+const writeFilePromise = (0, _util.promisify)(_fs.default.writeFile);
+exports.writeFilePromise = writeFilePromise;
+const readdirPromise = (0, _util.promisify)(_fs.default.readdir);
+exports.readdirPromise = readdirPromise;
+const statPromise = (0, _util.promisify)(_fs.default.stat);
+exports.statPromise = statPromise;
+const unlinkPromise = (0, _util.promisify)(_fs.default.unlink);
+exports.unlinkPromise = unlinkPromise;
+const rmdirPromise = (0, _util.promisify)(_fs.default.rmdir);
+exports.rmdirPromise = rmdirPromise;
+
+const readFilePromise = async path => {
+  return await readFile(path, 'utf8');
+};
+
+exports.readFilePromise = readFilePromise;
+//# sourceMappingURL=fs.js.map

package/build/fs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/fs.ts"],"names":["readFile","fs","mkdirPromise","mkdir","writeFilePromise","writeFile","readdirPromise","readdir","statPromise","stat","unlinkPromise","unlink","rmdirPromise","rmdir","readFilePromise","path"],"mappings":";;;;;;;AAAA;;AACA;;;;AAEA;AACA,MAAMA,QAAQ,GAAG,qBAAUC,YAAGD,QAAb,CAAjB;AACA,MAAME,YAAY,GAAG,qBAAUD,YAAGE,KAAb,CAArB;;AACA,MAAMC,gBAAgB,GAAG,qBAAUH,YAAGI,SAAb,CAAzB;;AACA,MAAMC,cAAc,GAAG,qBAAUL,YAAGM,OAAb,CAAvB;;AACA,MAAMC,WAAW,GAAG,qBAAUP,YAAGQ,IAAb,CAApB;;AACA,MAAMC,aAAa,GAAG,qBAAUT,YAAGU,MAAb,CAAtB;;AACA,MAAMC,YAAY,GAAG,qBAAUX,YAAGY,KAAb,CAArB;;;AAEO,MAAMC,eAAe,GAAG,MAAOC,IAAP,IAAgB;AAC7C,SAAO,MAAMf,QAAQ,CAACe,IAAD,EAAO,MAAP,CAArB;AACD,CAFM","sourcesContent":["import fs from 'fs';\nimport { promisify } from 'util';\n\n// FUTURE: when v15 is min replace by fs/promises\nconst readFile = promisify(fs.readFile);\nconst mkdirPromise = promisify(fs.mkdir);\nconst writeFilePromise = promisify(fs.writeFile);\nconst readdirPromise = promisify(fs.readdir);\nconst statPromise = promisify(fs.stat);\nconst unlinkPromise = promisify(fs.unlink);\nconst rmdirPromise = promisify(fs.rmdir);\n\nexport const readFilePromise = async (path) => {\n  return await readFile(path, 'utf8');\n};\n\nexport { mkdirPromise, writeFilePromise, readdirPromise, statPromise, unlinkPromise, rmdirPromise };\n"],"file":"fs.js"}

package/build/local-database.d.ts

@@ -1,44 +1,40 @@
-import { Callback, Config, IPackageStorage, IPluginStorage, LocalStorage, Logger } from '@verdaccio/types';
+import { pluginUtils, searchUtils } from '@verdaccio/core';
+import { Config, IPackageStorage, LocalStorage, Logger } from '@verdaccio/types';
 import TokenActions from './token';
-declare class LocalDatabase extends TokenActions implements IPluginStorage<{}> {
-    path: string;
-    logger: Logger;
-    data: LocalStorage;
-    config: Config;
+export declare const ERROR_DB_LOCKED = "Database is locked, please check error message printed during startup to prevent data loss";
+declare type IPluginStorage = pluginUtils.IPluginStorage<{}>;
+declare class LocalDatabase extends TokenActions implements IPluginStorage {
+    private readonly path;
+    private readonly logger;
+    readonly config: Config;
+    readonly storages: Map<string, string>;
+    data: LocalStorage | void;
     locked: boolean;
     constructor(config: Config, logger: Logger);
     init(): Promise<void>;
     getSecret(): Promise<string>;
-    setSecret(secret: string): Promise<Error | null>;
-    add(name: string, cb: Callback): void;
-    search(onPackage: Callback, onEnd: Callback, validateName: (name: string) => boolean): void;
-    remove(name: string, cb: Callback): void;
+    setSecret(secret: string): Promise<void>;
+    add(name: string): Promise<void>;
     /**
-     * Return all database elements.
-     * @return {Array}
-     */
-    get(cb: Callback): void;
+     * The field storage could be absolute or relative.
+     * If relative, it will be resolved against the config path.
+     * If absolute, it will be returned as is.
+     **/
+    private getStoragePath;
+    private getBaseConfigPath;
+    /**
+     * Filter by query.
+     **/
+    filterByQuery(results: searchUtils.SearchItemPkg[], query: searchUtils.SearchQuery): Promise<searchUtils.SearchItemPkg[]>;
+    getScore(_pkg: searchUtils.SearchItemPkg): Promise<searchUtils.Score>;
+    search(query: searchUtils.SearchQuery): Promise<searchUtils.SearchItem[]>;
+    remove(name: string): Promise<void>;
+    get(): Promise<any>;
     getPackageStorage(packageName: string): IPackageStorage;
-    clean(): void;
-    private getTime;
+    clean(): Promise<void>;
     private _getCustomPackageLocalStorages;
-    /**
-     * Syncronize {create} database whether does not exist.
-     * @return {Error|*}
-     */
     private _sync;
-    /**
-     * Verify the right local storage location.
-     * @param {String} path
-     * @return {String}
-     * @private
-     */
     private _getLocalStoragePath;
-    /**
-     * Fetch local packages.
-     * @private
-     * @return {Object}
-     */
     private _fetchLocalPackages;
 }
 export default LocalDatabase;