run transitive deps installation when using npm

Author: TMisiukiewicz

packages/cli/package.json

@@ -39,13 +39,15 @@
     "find-up": "^4.1.0",
     "fs-extra": "^8.1.0",
     "graceful-fs": "^4.1.3",
+    "npm-registry-fetch": "16.0.0",
     "prompts": "^2.4.2",
     "semver": "^7.5.2"
   },
   "devDependencies": {
     "@types/fs-extra": "^8.1.0",
     "@types/graceful-fs": "^4.1.3",
     "@types/hapi__joi": "^17.1.6",
+    "@types/npm-registry-fetch": "8.0.4",    
     "@types/prompts": "^2.4.4",
     "@types/semver": "^6.0.2",
     "deepmerge": "^4.3.0",

packages/cli/src/index.ts

@@ -10,7 +10,11 @@ import childProcess from 'child_process';
 import {Command as CommanderCommand} from 'commander';
 import path from 'path';
 import {detachedCommands, projectCommands} from './commands';
-import installTransitiveDeps from './tools/resolveTransitiveDeps';
+import installTransitiveDeps, {
+  resolvePodsInstallation,
+} from './tools/resolveTransitiveDeps';
+import {isProjectUsingYarn} from './tools/yarn';
+import generateFileHash from './tools/generateFileHash';
 
 const pkgJson = require('../package.json');
 
@@ -42,7 +46,6 @@ const handleError = (err: Error) => {
   }
   process.exit(1);
 };
-
 function printExamples(examples: Command['examples']) {
   let output: string[] = [];
 
@@ -172,11 +175,23 @@ async function setupAndRun() {
       );
     }
   }
-
-  // are peer dependencies installed?
-  await installTransitiveDeps();
+  // for now, run only if project is using npm
+  if (
+    process.argv.includes('--dependency-check') &&
+    !isProjectUsingYarn(process.cwd())
+  ) {
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    const preInstallHash = generateFileHash(packageJsonPath);
+    const areTransitiveDepsInstalled = await installTransitiveDeps();
+    const postInstallHash = generateFileHash(packageJsonPath);
+
+    if (areTransitiveDepsInstalled && preInstallHash !== postInstallHash) {
+      await resolvePodsInstallation();
+    }
+  }
 
   let config: Config | undefined;
+
   try {
     config = loadConfig();
 

packages/cli/src/tools/generateFileHash.ts

@@ -0,0 +1,14 @@
+import fs from 'fs-extra';
+import {createHash} from 'crypto';
+import {CLIError} from '@react-native-community/cli-tools';
+
+export default function generateFileHash(filePath: string) {
+  try {
+    const file = fs.readFileSync(filePath, {encoding: 'utf8'});
+    const hash = createHash('md5').update(file).digest('hex');
+
+    return hash;
+  } catch {
+    throw new CLIError('Failed to generate file hash.');
+  }
+}

packages/cli/src/tools/resolveTransitiveDeps.ts

@@ -1,17 +1,36 @@
 import path from 'path';
 import fs from 'fs-extra';
 import {getLoader, logger} from '@react-native-community/cli-tools';
+import * as fetch from 'npm-registry-fetch';
 import chalk from 'chalk';
 import {prompt} from 'prompts';
 import execa from 'execa';
+import semver from 'semver';
+import {isProjectUsingYarn} from './yarn';
+import {installPods} from '@react-native-community/cli-doctor';
 
 interface DependencyInfo {
   path: string;
   peerDependencies: {[key: string]: string};
 }
 
-function isUsingYarn(root: string) {
-  return fs.existsSync(path.join(root, 'yarn.lock'));
+async function fetchAvailableVersions(packageName: string): Promise<string[]> {
+  const response = await fetch.json(`/${packageName}`);
+
+  return Object.keys(response.versions || {});
+}
+
+async function calculateWorkingVersion(
+  ranges: string[],
+  availableVersions: string[],
+): Promise<string | null> {
+  const sortedVersions = availableVersions
+    .filter((version) =>
+      ranges.every((range) => semver.satisfies(version, range)),
+    )
+    .sort(semver.rcompare);
+
+  return sortedVersions.length > 0 ? sortedVersions[0] : null;
 }
 
 function getPeerDependencies(
@@ -61,21 +80,19 @@ function getPeerDependencies(
 function excludeInstalledPeerDependencies(
   root: string,
   peerDependencies: Map<string, DependencyInfo>,
-  yarn = true,
+  packageJson: any,
 ) {
-  const packageJson = require(path.join(root, 'package.json'));
   const missingPeerDependencies: Record<string, Record<string, string>> = {};
   peerDependencies.forEach((value, key) => {
     const missingDeps = Object.entries(value.peerDependencies).reduce(
       (missingDepsList, [name, version]) => {
         const rootPath = path.join(root, 'node_modules', name);
         if (
-          (yarn && !fs.existsSync(rootPath)) ||
-          (!yarn &&
-            (fs.existsSync(path.join(rootPath, 'ios')) ||
-              fs.existsSync(path.join(rootPath, 'android'))) &&
-            !Object.keys(packageJson.dependencies).includes(name))
+          (fs.existsSync(path.join(rootPath, 'ios')) ||
+            fs.existsSync(path.join(rootPath, 'android'))) &&
+          !Object.keys(packageJson.dependencies).includes(name)
         ) {
+          //@ts-ignore
           missingDepsList[name] = version;
         }
         return missingDepsList;
@@ -93,56 +110,110 @@ function excludeInstalledPeerDependencies(
 
 export default async function installTransitiveDeps() {
   const root = process.cwd();
-  const packageJsonPath = path.join(root, 'package.json');
-  const packageJson = require(packageJsonPath);
-  const isYarn = isUsingYarn(root);
-  const peerDependencies = getPeerDependencies(root, packageJson);
-  const depsToInstall = excludeInstalledPeerDependencies(
-    root,
-    peerDependencies,
-    isYarn,
-  );
-
-  const dependenciesWithMissingDeps = Object.keys(depsToInstall);
-  if (dependenciesWithMissingDeps.length > 0) {
-    logger.warn(
-      'Looks like you are missing some of the peer dependencies of your libraries:\n',
+  const isYarn = !!isProjectUsingYarn(root);
+
+  let newDependenciesFound = true;
+
+  while (newDependenciesFound) {
+    const packageJsonPath = path.join(root, 'package.json');
+    const packageJson = JSON.parse(
+      fs.readFileSync(packageJsonPath, {encoding: 'utf8'}),
     );
-    logger.log(
-      dependenciesWithMissingDeps
-        .map(
-          (dep) =>
-            `\t${chalk.bold(dep)}:\n ${Object.keys(depsToInstall[dep]).map(
-              (d) => `\t- ${d}\n`,
-            )}`,
-        )
-        .join('\n')
-        .replace(/,/g, ''),
+    const peerDependencies = getPeerDependencies(root, packageJson);
+    const depsToInstall = excludeInstalledPeerDependencies(
+      root,
+      peerDependencies,
+      packageJson,
     );
-    const {install} = await prompt({
-      type: 'confirm',
-      name: 'install',
-      message:
-        'Do you want to install them now? The matching versions will be added as project dependencies and become visible for autolinking.',
-    });
-    const loader = getLoader({text: 'Installing peer dependencies...'});
-
-    if (install) {
-      let deps = new Set();
-      dependenciesWithMissingDeps.map((dep) => {
-        const missingDeps = depsToInstall[dep];
-        deps.add(Object.keys(missingDeps));
+    const dependenciesWithMissingDeps = Object.keys(depsToInstall);
+
+    if (dependenciesWithMissingDeps.length > 0) {
+      logger.warn(
+        'Looks like you are missing some of the peer dependencies of your libraries:\n',
+      );
+      logger.log(
+        dependenciesWithMissingDeps
+          .map(
+            (dep) =>
+              `\t${chalk.bold(dep)}:\n ${Object.keys(depsToInstall[dep]).map(
+                (d) => `\t- ${d}\n`,
+              )}`,
+          )
+          .join('\n')
+          .replace(/,/g, ''),
+      );
+
+      const packageToRanges: {[pkg: string]: string[]} = {};
+
+      for (const dependency in depsToInstall) {
+        const packages = depsToInstall[dependency];
+
+        for (const packageName in packages) {
+          if (!packageToRanges[packageName]) {
+            packageToRanges[packageName] = [];
+          }
+          packageToRanges[packageName].push(packages[packageName]);
+        }
+      }
+
+      const workingVersions: {[pkg: string]: string | null} = {};
+
+      for (const packageName in packageToRanges) {
+        const ranges = packageToRanges[packageName];
+        const availableVersions = await fetchAvailableVersions(packageName);
+        const workingVersion = await calculateWorkingVersion(
+          ranges,
+          availableVersions,
+        );
+        workingVersions[packageName] = workingVersion;
+      }
+
+      const {install} = await prompt({
+        type: 'confirm',
+        name: 'install',
+        message:
+          'Do you want to install them now? The matching versions will be added as project dependencies and become visible for autolinking.',
       });
-      const arr = Array.from(deps) as string[];
-      const flat = [].concat(...arr);
-      loader.start();
+      const loader = getLoader({text: 'Installing peer dependencies...'});
+
+      if (install) {
+        const arr = Object.entries(workingVersions).map(
+          ([name, version]) => `${name}@^${version}`,
+        );
+        //@ts-ignore
+        const flat = [].concat(...arr);
+
+        loader.start();
 
-      if (isYarn) {
-        execa.sync('yarn', ['add', ...flat.map((dep) => dep)]);
+        if (isYarn) {
+          execa.sync('yarn', ['add', ...flat.map((dep) => dep)]);
+        } else {
+          execa.sync('npm', ['install', ...flat.map((dep) => dep)]);
+        }
+        loader.succeed();
       } else {
-        execa.sync('npm', ['install', ...flat.map((dep) => dep)]);
+        newDependenciesFound = false;
       }
-      loader.succeed();
+    } else {
+      newDependenciesFound = false;
     }
   }
+
+  return !newDependenciesFound;
+}
+
+export async function resolvePodsInstallation() {
+  const {install} = await prompt({
+    type: 'confirm',
+    name: 'install',
+    message:
+      'Do you want to install pods? This will make sure your transitive dependencies are linked properly.',
+  });
+
+  if (install && process.platform === 'darwin') {
+    const loader = getLoader({text: 'Installing pods...'});
+    loader.start();
+    await installPods(loader);
+    loader.succeed();
+  }
 }