How to actually manage single-version policy for deployments

[31i0t]

I've frequently heard it's best practice to have a single node_modules folder and package.json (with deps) at the root of the project so that every app shares the same versions of packages. But then, this means that when you deploy, you have to install every dependency across all of your projects. The generatePackageJson flag also isn't much help because it populates peer dependencies by looking in the node_modules folder. I made an executor to combat this which installs a minimum amount of dependencies in the root, and can find all dependencies needed for a project by resolving peer dependencies via checking the npm registry and dependencies for any projects in lib/* for a lightweight deployment.

Let me know if you've found better solutions to this problem!

import chalk from "chalk";
import { execSync } from 'child_process';
import { readJsonFile, readCachedProjectGraph, readJson } from "@nrwl/devkit";
import rJSON from "relaxed-json";
import { flow, forEach, map, filter, replace, flatMap, uniq, isNil, keys, join, toPairs, find } from "lodash/fp";

import type { ExecutorContext, ProjectGraphDependency } from "@nrwl/devkit"

interface Schema {
	preInstallPackages: string[]
}
interface FetchedPeerDependencies {
	[key: string]: string;
}

const initialPackageMatchers: (RegExp | string)[] = [
	/^@nrwl.*/,
	"nx",
	"chalk",
	"relaxed-json",
	"lodash"
]

const getLibDependencies = (
	projectName: string,
	dependencies: Record<string, ProjectGraphDependency[]>,
	libDependencies = []
) => {
	const projectDeps = dependencies[projectName];
	const libDependenciesOfProject = filter(({ target }) => !target.startsWith("npm"), projectDeps);

	forEach(({ target }) => {
		getLibDependencies(target, dependencies, libDependencies);
	}, libDependenciesOfProject)

	libDependencies.push(filter(({ target }) => target.startsWith("npm"), projectDeps))
	return flow(
		flatMap((deps: ProjectGraphDependency[]) => map(({ target }) => target, deps)),
		uniq,
	)(libDependencies)
}

const fetchPeerDependencies = (targetPackage: string): FetchedPeerDependencies => {
	const peerDependencies = execSync(`npm info ${targetPackage} peerDependencies`, { encoding: 'utf-8' });
	
	return peerDependencies === ""
		? {}
		: rJSON.parse(peerDependencies)
}

const getPeerDependencies = (packageName: string, peerDependencies = []) => {
	if (find(packageName, keys(peerDependencies))) {
		return;
	}

	const fetchedPeerDependencies = fetchPeerDependencies(packageName);
	forEach((peerDep) => {
		getPeerDependencies(peerDep);
	}, keys(fetchedPeerDependencies))

	peerDependencies.push(fetchedPeerDependencies);
	return flow(
		map((peerDeps) => keys(peerDeps)),
		flatMap((deps) => deps),
		uniq
	)(peerDependencies)
}

const installPackages = async (
	{ preInstallPackages = [] }: Schema,
	{ projectName, root }: ExecutorContext
) => {
	const {
		dependencies: rootDependencies,
		devDependencies: rootDevDependencies
	} = readJsonFile(`${root}/package.json`);
	
	const initialPackages = flow(
		keys,
		(matchers) => [...matchers, ...preInstallPackages],
		filter((dep) => Boolean(
			find((matcher) => typeof matcher === "string"
					? matcher === dep
					: matcher.test(dep)
			, initialPackageMatchers
		)))	
	)({ ...rootDevDependencies, ...rootDependencies });

	console.log(chalk.bold.green(`Identified the following initial packages:\n`))
	forEach((dep) => {
		console.log(`  ${chalk.bold(dep)}\n`)
	}, initialPackages)
	execSync(`npm install ${join(' ', initialPackages)} --no-save`);

	const { dependencies } = readCachedProjectGraph();
	const withLibDeps = getLibDependencies(projectName, dependencies)
	const withoutDevDependencies = flow(
		map((dep: string) => replace('npm:', '', dep)),
		filter((dep) => dep in rootDependencies)
	)(withLibDeps);
	const withPeerDependencies = flow(
		map((dep: string) => getPeerDependencies(dep)),
		flatMap((deps) => deps),
		(deps) => [...deps, ...withoutDevDependencies],
		uniq,
		filter((dep) => !isNil(dep)),
		filter((dep) => dep in rootDependencies)
	)(withoutDevDependencies);

	console.log(chalk.bold.green(`Identified the following dependencies:\n`))
	forEach((dep) => {
		console.log(`  ${chalk.bold(dep)}\n`)
	}, withPeerDependencies)


	
	execSync(`npm install ${join(" ", withPeerDependencies)} --no-save`)

	return { success: true }
}

export default installPackages;