@verdaccio/local-storage/lib/dir-utils.js

Local storage implementation

"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(e) { return e && e.__esModule ? e : { default: e }; }
const debug = (0, _debug.default)('verdaccio:plugin:local-storage:dir-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 forbidden 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());
  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