flow-typed/dist/lib/libDefs.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports._cacheRepoAssure = exports._REMOTE_REPO_URL = exports._LAST_UPDATED_FILE = exports._CACHE_REPO_GIT_DIR = exports._CACHE_REPO_EXPIRY = exports._CACHE_REPO_DIR = exports.TEST_FILE_NAME_RE = void 0;
exports._ensureCacheRepo = ensureCacheRepo;
exports.filterLibDefs = filterLibDefs;
exports.getCacheLibDefs = getCacheLibDefs;
exports.getLibDefs = getLibDefs;
exports.parseRepoDirItem = parseRepoDirItem;
exports.updateCacheRepo = updateCacheRepo;

var _semver = _interopRequireDefault(require("semver"));

var _git = require("./git.js");

var _fileUtils = require("./fileUtils.js");

var _node = require("./node.js");

var _semver2 = require("./semver.js");

var _flowVersion = require("./flowVersion.js");

var _ValidationError = require("./ValidationError");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const P = Promise;
const TEST_FILE_NAME_RE = /^test_.*\.js$/;
exports.TEST_FILE_NAME_RE = TEST_FILE_NAME_RE;

const CACHE_DIR = _node.path.join(_node.os.homedir(), '.flow-typed');

const CACHE_REPO_DIR = _node.path.join(CACHE_DIR, 'repo');

exports._CACHE_REPO_DIR = CACHE_REPO_DIR;
const REMOTE_REPO_URL = 'https://github.com/flowtype/flow-typed.git';
exports._REMOTE_REPO_URL = REMOTE_REPO_URL;

const LAST_UPDATED_FILE = _node.path.join(CACHE_DIR, 'lastUpdated');

exports._LAST_UPDATED_FILE = LAST_UPDATED_FILE;

async function cloneCacheRepo(verbose) {
  await (0, _fileUtils.mkdirp)(CACHE_REPO_DIR);

  try {
    await (0, _git.cloneInto)(REMOTE_REPO_URL, CACHE_REPO_DIR);
  } catch (e) {
    writeVerbose(verbose, 'ERROR: Unable to clone the local cache repo.');
    throw e;
  }

  await _node.fs.writeFile(LAST_UPDATED_FILE, String(Date.now()));
}

const CACHE_REPO_GIT_DIR = _node.path.join(CACHE_REPO_DIR, '.git');

exports._CACHE_REPO_GIT_DIR = CACHE_REPO_GIT_DIR;

async function rebaseCacheRepo(verbose) {
  if ((await _node.fs.exists(CACHE_REPO_DIR)) && (await _node.fs.exists(CACHE_REPO_GIT_DIR))) {
    try {
      await (0, _git.rebaseRepoMainline)(CACHE_REPO_DIR);
    } catch (e) {
      writeVerbose(verbose, 'ERROR: Unable to rebase the local cache repo. ' + e.message);
      return false;
    }

    await _node.fs.writeFile(LAST_UPDATED_FILE, String(Date.now()));
    return true;
  } else {
    await cloneCacheRepo(verbose);
    return true;
  }
}
/**
 * Utility wrapper for ensureCacheRepo with an update expiry of 0 hours.
 */


async function updateCacheRepo(verbose) {
  return await ensureCacheRepo(verbose, 0);
}
/**
 * Ensure that the CACHE_REPO_DIR exists and is recently rebased.
 * (else: create/rebase it)
 */


const CACHE_REPO_EXPIRY = 1000 * 60; // 1 minute

exports._CACHE_REPO_EXPIRY = CACHE_REPO_EXPIRY;
const _cacheRepoAssure = {
  lastAssured: 0,
  pendingAssure: Promise.resolve()
};
exports._cacheRepoAssure = _cacheRepoAssure;

async function ensureCacheRepo(verbose, cacheRepoExpiry = CACHE_REPO_EXPIRY) {
  // Only re-run rebase checks if a check hasn't been run in the last 5 minutes
  if (_cacheRepoAssure.lastAssured + 5 * 1000 * 60 >= Date.now()) {
    return _cacheRepoAssure.pendingAssure;
  }

  _cacheRepoAssure.lastAssured = Date.now();
  const prevAssure = _cacheRepoAssure.pendingAssure;
  return _cacheRepoAssure.pendingAssure = prevAssure.then(() => async function () {
    const repoDirExists = _node.fs.exists(CACHE_REPO_DIR);

    const repoGitDirExists = _node.fs.exists(CACHE_REPO_GIT_DIR);

    if (!(await repoDirExists) || !(await repoGitDirExists)) {
      writeVerbose(verbose, '• flow-typed cache not found, fetching from GitHub...', false);
      await cloneCacheRepo(verbose);
      writeVerbose(verbose, 'done.');
    } else {
      let lastUpdated = 0;

      if (await _node.fs.exists(LAST_UPDATED_FILE)) {
        // If the LAST_UPDATED_FILE has anything other than just a number in
        // it, just assume we need to update.
        const lastUpdatedRaw = await _node.fs.readFile(LAST_UPDATED_FILE);
        const lastUpdatedNum = parseInt(lastUpdatedRaw, 10);

        if (String(lastUpdatedNum) === String(lastUpdatedRaw)) {
          lastUpdated = lastUpdatedNum;
        }
      }

      if (lastUpdated + cacheRepoExpiry < Date.now()) {
        writeVerbose(verbose, '• rebasing flow-typed cache...', false);
        const rebaseSuccessful = await rebaseCacheRepo(verbose);

        if (rebaseSuccessful) {
          writeVerbose(verbose, 'done.');
        } else {
          writeVerbose(verbose, "\nNOTE: Unable to rebase local cache! If you don't currently " + "have internet connectivity, no worries -- we'll update the " + 'local cache the next time you do.\n');
        }
      }
    }
  }());
} // Exported for tests -- since we really want this part well-tested.


async function addLibDefs(pkgDirPath, libDefs) {
  const parsedDirItem = parseRepoDirItem(pkgDirPath);
  (await parseLibDefsFromPkgDir(parsedDirItem, pkgDirPath)).forEach(libDef => libDefs.push(libDef));
}
/**
 * Given a 'definitions/...' dir, return a list of LibDefs that it contains.
 */


async function getLibDefs(defsDir) {
  const libDefs = [];
  const defsDirItems = await _node.fs.readdir(defsDir);
  await P.all(defsDirItems.map(async item => {
    if ((0, _fileUtils.isExcludedFile)(item)) return;

    const itemPath = _node.path.join(defsDir, item);

    const itemStat = await _node.fs.stat(itemPath);

    if (itemStat.isDirectory()) {
      if (item.charAt(0) === '@') {
        // directory is of the form '@<scope>', so go one level deeper
        const scope = item;
        const defsDirItems = await _node.fs.readdir(itemPath);
        await P.all(defsDirItems.map(async item => {
          if ((0, _fileUtils.isExcludedFile)(item)) return;

          const itemPath = _node.path.join(defsDir, scope, item);

          const itemStat = await _node.fs.stat(itemPath);

          if (itemStat.isDirectory()) {
            // itemPath is a lib dir
            await addLibDefs(itemPath, libDefs);
          } else {
            const error = `Expected only directories in the 'definitions/npm/@<scope>' directory! Please remove or change ${itemPath}`;
            throw new _ValidationError.ValidationError(error);
          }
        }));
      } else {
        // itemPath is a lib dir
        await addLibDefs(itemPath, libDefs);
      }
    } else {
      const error = `Expected only directories in the 'definitions/npm' directory! Please remove or change ${itemPath}`;
      throw new _ValidationError.ValidationError(error);
    }
  }));
  return libDefs;
}

function parsePkgFlowDirVersion(pkgFlowDirPath) {
  const pkgFlowDirName = _node.path.basename(pkgFlowDirPath);

  return (0, _flowVersion.parseDirString)(pkgFlowDirName);
}
/**
 * Given a parsed package name and version and a path to the package directory
 * on disk, scan the directory and generate a list of LibDefs for each
 * flow-versioned definition file.
 */


async function parseLibDefsFromPkgDir({
  pkgName,
  pkgVersion
}, pkgDirPath) {
  const pkgVersionStr = (0, _semver2.versionToString)(pkgVersion);
  const pkgDirItems = await _node.fs.readdir(pkgDirPath);
  const commonTestFiles = [];
  const flowDirs = [];
  pkgDirItems.forEach(pkgDirItem => {
    const pkgDirItemPath = _node.path.join(pkgDirPath, pkgDirItem);

    const pkgDirItemStat = _node.fs.statSync(pkgDirItemPath);

    if (pkgDirItemStat.isFile()) {
      if (_node.path.extname(pkgDirItem) === '.swp') {
        return;
      }

      const isValidTestFile = validateTestFile(pkgDirItemPath);

      if (isValidTestFile) {
        commonTestFiles.push(pkgDirItemPath);
      }
    } else if (pkgDirItemStat.isDirectory()) {
      flowDirs.push([pkgDirItemPath, parsePkgFlowDirVersion(pkgDirItemPath)]);
    } else {
      throw new _ValidationError.ValidationError('Unexpected directory item: ' + pkgDirItemPath);
    }
  });

  if (!(0, _flowVersion.disjointVersionsAll)(flowDirs.map(([_, ver]) => ver))) {
    throw new _ValidationError.ValidationError(`Flow versions not disjoint on ${pkgName}`);
  }

  if (flowDirs.length === 0) {
    throw new _ValidationError.ValidationError(`No libdef files found in ${pkgDirPath}!`);
  }

  const libDefs = [];
  await P.all(flowDirs.map(async ([flowDirPath, flowVersion]) => {
    var _configPath;

    const testFilePaths = [].concat(commonTestFiles);
    const basePkgName = pkgName.charAt(0) === '@' ? pkgName.split(_node.path.sep).pop() : pkgName;
    const libDefFileName = pkgVersionStr === 'vx.x.x' ? `${basePkgName}.js` : `${basePkgName}_${pkgVersionStr}.js`;
    let libDefFilePath;
    let configPath;
    (await _node.fs.readdir(flowDirPath)).forEach(flowDirItem => {
      const flowDirItemPath = _node.path.join(flowDirPath, flowDirItem);

      const flowDirItemStat = _node.fs.statSync(flowDirItemPath);

      if (flowDirItemStat.isFile()) {
        // If we couldn't discern the package name, we've already recorded an
        // error for that -- so try to avoid spurious downstream errors.
        if (pkgName === 'ERROR') {
          return;
        }

        if (_node.path.extname(flowDirItem) === '.swp') {
          return;
        }

        if (flowDirItem === 'config.json') {
          configPath = _node.path.join(flowDirPath, flowDirItem);
          return;
        }

        if (flowDirItem === libDefFileName) {
          libDefFilePath = _node.path.join(flowDirPath, flowDirItem);
          return;
        }

        const isValidTestFile = validateTestFile(flowDirItemPath);

        if (isValidTestFile) {
          testFilePaths.push(flowDirItemPath);
        }
      } else {
        const error = 'Unexpected directory item: ' + flowDirItemPath;
        throw new _ValidationError.ValidationError(error);
      }
    });

    if (libDefFilePath == null) {
      libDefFilePath = _node.path.join(flowDirPath, libDefFileName);

      if (pkgName !== 'ERROR') {
        const error = `No libdef file found in ${flowDirPath}`;
        throw new _ValidationError.ValidationError(error);
      }

      return;
    }

    libDefs.push({
      pkgName,
      pkgVersionStr,
      configPath: (_configPath = configPath) !== null && _configPath !== void 0 ? _configPath : null,
      flowVersion: flowVersion,
      flowVersionStr: (0, _flowVersion.toDirString)(flowVersion),
      path: libDefFilePath,
      testFilePaths
    });
  }));
  return libDefs;
}
/**
 * Given the path to a directory item in the 'definitions' directory, parse the
 * directory's name into a package name and version.
 */


const REPO_DIR_ITEM_NAME_RE = /^(.*)_v([0-9]+)\.([0-9]+|x)\.([0-9]+|x)(-.*)?$/;

function parseRepoDirItem(dirItemPath) {
  const dirItem = _node.path.basename(dirItemPath); // env definitions don't have versions nor need any sort of name validation


  if (dirItemPath.includes('definitions/environments')) {
    return {
      pkgName: dirItem,
      pkgVersion: {
        major: 'x',
        minor: 'x',
        patch: 'x',
        prerel: null
      }
    };
  }

  const itemMatches = dirItem.match(REPO_DIR_ITEM_NAME_RE);

  if (itemMatches == null) {
    const error = `'${dirItem}' is a malformed definitions/npm/ directory name! ` + `Expected the name to be formatted as <PKGNAME>_v<MAJOR>.<MINOR>.<PATCH>`;
    throw new _ValidationError.ValidationError(error);
  }

  const [_, pkgName, majorStr, minorStr, patchStr, prerel] = itemMatches;

  const item = _node.path.dirname(dirItemPath).split(_node.path.sep).pop();

  const major = validateVersionNumPart(majorStr, 'major', dirItemPath);
  const minor = validateVersionPart(minorStr, 'minor', dirItemPath);
  const patch = validateVersionPart(patchStr, 'patch', dirItemPath);
  return {
    pkgName: item.charAt(0) === '@' ? `${item}${_node.path.sep}${pkgName}` : pkgName,
    pkgVersion: {
      major,
      minor,
      patch,
      prerel: prerel != null ? prerel.substr(1) : prerel
    }
  };
}
/**
 * Given a path to an assumed test file, ensure that it is named as expected.
 */


function validateTestFile(testFilePath) {
  const testFileName = _node.path.basename(testFilePath);

  return TEST_FILE_NAME_RE.test(testFileName);
}
/**
 * Given a number-only part of a version string (i.e. the `major` part), parse
 * the string into a number.
 */


function validateVersionNumPart(part, partName, context) {
  const num = parseInt(part, 10);

  if (String(num) !== part) {
    const error = `'${context}': Invalid ${partName} number: '${part}'. Expected a number.`;
    throw new _ValidationError.ValidationError(error);
  }

  return num;
}
/**
 * Given a number-or-wildcard part of a version string (i.e. a `minor` or
 * `patch` part), parse the string into either a number or 'x'.
 */


function validateVersionPart(part, partName, context) {
  if (part === 'x') {
    return part;
  }

  return validateVersionNumPart(part, partName, context);
}
/**
 * Given a path to a 'definitions' dir, assert that the currently-running
 * version of the CLI is compatible with the repo.
 */


async function verifyCLIVersion(defsDirPath) {
  var _semver$coerce;

  const metadataFilePath = _node.path.join(defsDirPath, '.cli-metadata.json');

  const metadata = await _node.fs.readJson(metadataFilePath);

  if (!metadata.compatibleCLIRange) {
    throw new Error(`Unable to find the 'compatibleCLIRange' property in ` + `${metadataFilePath}. You might need to update to a newer version of ` + `the Flow CLI.`);
  }

  const minCLIVersion = metadata.compatibleCLIRange;

  const thisCLIVersion = require('../../package.json').version;

  if (!_semver.default.satisfies((_semver$coerce = _semver.default.coerce(thisCLIVersion)) !== null && _semver$coerce !== void 0 ? _semver$coerce : thisCLIVersion, minCLIVersion)) {
    throw new Error(`Please upgrade your CLI version! This CLI is version ` + `${thisCLIVersion}, but the latest flow-typed definitions are only ` + `compatible with flow-typed@${minCLIVersion}`);
  }
}
/**
 * Helper function to write verbose output only when an output stream was
 * provided.
 */


function writeVerbose(stream, msg, writeNewline = true) {
  if (stream != null) {
    stream.write(msg + (writeNewline ? '\n' : ''));
  }
}
/**
 * Get a list of LibDefs from the flow-typed cache repo checkout.
 *
 * If the repo checkout does not exist or is out of date, it will be
 * created/updated automatically first.
 */


const CACHE_REPO_DEFS_DIR = _node.path.join(CACHE_REPO_DIR, 'definitions', 'npm');

async function getCacheLibDefs(verbose = process.stdout) {
  await ensureCacheRepo(verbose);
  await verifyCLIVersion(_node.path.join(CACHE_REPO_DIR, 'definitions'));
  return getLibDefs(CACHE_REPO_DEFS_DIR);
}

function packageNameMatch(a, b) {
  return a.toLowerCase() === b.toLowerCase();
}

function libdefMatchesPackageVersion(pkgSemver, defVersionRaw) {
  // The libdef version should be treated as a semver prefixed by a carat
  // (i.e: "foo_v2.2.x" is the same range as "^2.2.x")
  // UNLESS it is prefixed by the equals character (i.e. "foo_=v2.2.x")
  let defVersion = defVersionRaw;

  if (defVersionRaw[0] !== '=' && defVersionRaw[0] !== '^') {
    defVersion = '^' + defVersionRaw;
  }

  if (_semver.default.valid(pkgSemver)) {
    // test the single package version against the libdef range
    return _semver.default.satisfies(pkgSemver, defVersion);
  }

  if (_semver.default.valid(defVersion)) {
    // test the single defVersion agains the package range
    return _semver.default.satisfies(defVersion, pkgSemver);
  }

  const pkgRange = new _semver.default.Range(pkgSemver);
  const defRange = new _semver.default.Range(defVersion);

  if (defRange.set[0].length !== 2) {
    throw Error('Invalid libDef version, It appears to be a non-contiguous range.');
  }

  const defLowerB = defRange.set[0][0].semver.version;
  const defUpperB = defRange.set[0][1].semver.version;

  if (_semver.default.gtr(defLowerB, pkgSemver) || _semver.default.ltr(defUpperB, pkgSemver)) {
    return false;
  }

  const pkgLowerB = pkgRange.set[0][0].semver.version;
  return defRange.test(pkgLowerB);
}
/**
 * Filter a given list of LibDefs down using a specified filter.
 */


function filterLibDefs(defs, filter) {
  return defs.filter(def => {
    let filterMatch = false;

    switch (filter.type) {
      case 'exact':
        filterMatch = packageNameMatch(def.pkgName, filter.pkgName) && libdefMatchesPackageVersion(filter.pkgVersionStr, def.pkgVersionStr);
        break;

      case 'exact-name':
        filterMatch = packageNameMatch(def.pkgName, filter.term);
        break;

      case 'fuzzy':
        filterMatch = def.pkgName.toLowerCase().indexOf(filter.term.toLowerCase()) !== -1;
        break;

      default:
        throw new Error(`'${filter.type}' is an unexpected filter type! This should never ` + `happen!`);
    }

    if (!filterMatch) {
      return false;
    }

    const filterFlowVerStr = filter.flowVersionStr;

    if (filterFlowVerStr) {
      const {
        flowVersion
      } = def;

      switch (flowVersion.kind) {
        case 'all':
          return _semver.default.satisfies(filterFlowVerStr, def.flowVersionStr);

        case 'specific':
          return _semver.default.satisfies(filterFlowVerStr, def.flowVersionStr);

        case 'ranged':
          const {
            upper
          } = flowVersion;

          if (upper) {
            const lowerSpecific = {
              kind: 'ranged',
              upper: null,
              lower: flowVersion.lower
            };
            const lowerSpecificSemver = (0, _flowVersion.toSemverString)(lowerSpecific);
            const upperSpecificSemver = (0, _flowVersion.toSemverString)({
              kind: 'specific',
              ver: upper
            });
            return _semver.default.satisfies(filterFlowVerStr, lowerSpecificSemver) && _semver.default.satisfies(filterFlowVerStr, upperSpecificSemver);
          } else {
            return _semver.default.satisfies(filterFlowVerStr, (0, _flowVersion.toSemverString)(def.flowVersion));
          }

        default:
          flowVersion;
          throw new Error('Unexpected FlowVersion kind!');
      }
    }

    return true;
  }).sort((a, b) => {
    const aZeroed = a.pkgVersionStr.replace(/x/g, '0');
    const bZeroed = b.pkgVersionStr.replace(/x/g, '0');

    const pkgCompare = _semver.default.compare(aZeroed, bZeroed);

    if (pkgCompare !== 0) return -pkgCompare;
    const aFlowVersionStr = a.flowVersionStr;
    const bFlowVersionStr = b.flowVersionStr;
    if (aFlowVersionStr == null) return 1;
    if (bFlowVersionStr == null) return -1;
    const aFlowVersion = (0, _flowVersion.parseDirString)(aFlowVersionStr);
    const bFlowVersion = (0, _flowVersion.parseDirString)(bFlowVersionStr);
    return -1 * (0, _flowVersion.compareFlowVersionAsc)(aFlowVersion, bFlowVersion);
  });
}