getWorkspacePackages.js

"use strict";

const path = require("path");
const findUp = require("find-up");
const globby = require("globby");

const getLernaRoot = () => findUp.sync("lerna.json");
const getPackageJsonRoot = () => findUp.sync("package.json");

const toPackageJsonPath = originalPath =>
  path.relative(path.dirname(originalPath), "package.json");

const DEFAULT_WORKSPACES = ["packages/*"];

const getPackages = ({ resolvePackageJsons = true } = {}) => {
  const lernaRoot = getLernaRoot();

  if (!lernaRoot) {
    const packageJsonRoot = getPackageJsonRoot();
    if (packageJsonRoot) {
      return resolvePackageJsons ? require(packageJsonRoot) : packageJsonRoot;
    } else {
      throw new Error("getPackages() could not find any packages at all...");
    }
  }

  const lernaJson = require(lernaRoot);

  let workspaces = DEFAULT_WORKSPACES;
  if (lernaJson.useWorkspaces) {
    const npmClient = lernaJson.npmClient || "npm";
    switch (npmClient) {
      case "yarn": {
        const rootPackageJson = require(toPackageJsonPath(lernaRoot));
        workspaces =
          (Array.isArray(rootPackageJson.workspaces)
            ? rootPackageJson.workspaces
            : rootPackageJson.packages) || DEFAULT_WORKSPACES;
        break;
      }
      default:
      case "npm": {
        workspaces = lernaJson.workspaces || DEFAULT_WORKSPACES;
        break;
      }
    }
  }

  const packageJsonPaths = globby
    .sync(workspaces)
    .map(pkgDir => toPackageJsonPath(pkgDir));

  return resolvePackageJsons
    ? packageJsonPaths.map(pkgJsonPath => require(pkgJsonPath) || {})
    : packageJsonPaths;
};

const toDependencyList = (packageJsons = []) => {
  const dependencyList = Object.values(
    packageJsons.reduce((totalDependencies, pkgJson) => {
      const { dependencies = {}, devDependencies = {} } = pkgJson;
      for (let [name, version] of Object.entries(dependencies)) {
        const tag = `${name}@${version}`;
        if (!totalDependencies[tag]) {
          totalDependencies[tag] = {
            type: ["dependencies"],
            name,
            version
          };
        } else if (
          totalDependencies[tag].type.includes("dependencies") === false
        ) {
          totalDependencies[tag].type.push("dependencies");
        }
      }
      for (let [name, version] of Object.entries(devDependencies)) {
        const tag = `${name}@${version}`;
        if (!totalDependencies[tag]) {
          totalDependencies[tag] = {
            type: ["devDependencies"],
            name,
            version
          };
        } else if (
          totalDependencies[tag].type.includes("devDependencies") === false
        ) {
          totalDependencies[tag].type.push("devDependencies");
        }
      }

      return totalDependencies;
    }, {})
  );

  return dependencyList;
};

const packages = getPackages();

const dependencyList = toDependencyList(packages);

console.log("dependency list:");
console.log(dependencyList);