make transitive native libs visible for autolinking with npm

TMisiukiewicz · TMisiukiewicz · commit d77fe2ecdf27 · 2023-08-28T16:11:19.000+02:00
diff --git a/packages/cli-tools/package.json b/packages/cli-tools/package.json
@@ -7,6 +7,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@react-native-community/cli-doctor": "12.0.0-alpha.7",
     "appdirsjs": "^1.2.4",
     "chalk": "^4.1.2",
     "find-up": "^5.0.0",
diff --git a/packages/cli-tools/src/generateFileHash.ts b/packages/cli-tools/src/generateFileHash.ts
@@ -1,6 +1,6 @@
 import fs from 'fs-extra';
 import {createHash} from 'crypto';
-import {CLIError} from '@react-native-community/cli-tools';
+import {CLIError} from './errors';
 
 export default function generateFileHash(filePath: string) {
   try {
diff --git a/packages/cli-tools/src/index.ts b/packages/cli-tools/src/index.ts
@@ -17,5 +17,6 @@ export * as link from './doclink';
 export {default as startServerInNewWindow} from './startServerInNewWindow';
 export {default as handlePortUnavailable} from './handlePortUnavailable';
 export * from './port';
+export * as transitiveDeps from './resolveTransitiveDeps';
 
 export * from './errors';
diff --git a/packages/cli-tools/src/resolveTransitiveDeps.ts b/packages/cli-tools/src/resolveTransitiveDeps.ts
@@ -0,0 +1,314 @@
+import {installPods} from '@react-native-community/cli-doctor';
+import fs from 'fs-extra';
+import path from 'path';
+import * as fetch from 'npm-registry-fetch';
+import chalk from 'chalk';
+import {prompt} from 'prompts';
+import execa from 'execa';
+import semver from 'semver';
+import generateFileHash from './generateFileHash';
+import {getLoader} from './loader';
+import logger from './logger';
+
+interface DependencyData {
+  path: string;
+  version: string;
+  peerDependencies: {[key: string]: string};
+  duplicates?: DependencyData[];
+}
+
+export 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 findDependencyPath(
+  dependencyName: string,
+  rootPath: string,
+  parentPath: string,
+) {
+  let dependencyPath;
+  const topLevelPath = path.join(rootPath, 'node_modules', dependencyName);
+  const nestedPath = path.join(parentPath, 'node_modules', dependencyName);
+
+  if (fs.existsSync(topLevelPath)) {
+    dependencyPath = topLevelPath;
+  } else if (fs.existsSync(nestedPath)) {
+    dependencyPath = nestedPath;
+  }
+
+  return dependencyPath;
+}
+
+export function collectDependencies(root: string): Map<string, DependencyData> {
+  const dependencies = new Map<string, DependencyData>();
+
+  const checkDependency = (dependencyPath: string) => {
+    const packageJsonPath = path.join(dependencyPath, 'package.json');
+    const packageJson = require(packageJsonPath);
+
+    if (dependencies.has(packageJson.name)) {
+      const dependency = dependencies.get(packageJson.name) as DependencyData;
+
+      if (
+        dependencyPath !== dependency.path &&
+        dependency.duplicates?.every(
+          (duplicate) => duplicate.path !== dependencyPath,
+        )
+      ) {
+        dependencies.set(packageJson.name, {
+          ...dependency,
+          duplicates: [
+            ...dependency.duplicates,
+            {
+              path: dependencyPath,
+              version: packageJson.version,
+              peerDependencies: packageJson.peerDependencies,
+            },
+          ],
+        });
+      }
+      return;
+    }
+
+    dependencies.set(packageJson.name, {
+      path: dependencyPath,
+      version: packageJson.version,
+      peerDependencies: packageJson.peerDependencies,
+      duplicates: [],
+    });
+
+    for (const dependency in {
+      ...packageJson.dependencies,
+      ...(root === dependencyPath ? packageJson.devDependencies : {}),
+    }) {
+      const depPath = findDependencyPath(dependency, root, dependencyPath);
+
+      if (depPath) {
+        checkDependency(depPath);
+      }
+    }
+  };
+
+  checkDependency(root);
+
+  return dependencies;
+}
+
+function filterNativeDependencies(
+  root: string,
+  dependencies: Map<string, DependencyData>,
+) {
+  const depsWithNativePeers = new Map<string, Map<string, string>>();
+
+  dependencies.forEach((value, key) => {
+    if (value.peerDependencies) {
+      const nativeDependencies = new Map<string, string>();
+
+      Object.entries(value.peerDependencies).forEach(([name, versions]) => {
+        const dependencyPath = findDependencyPath(name, root, value.path);
+
+        if (dependencyPath) {
+          const iosPath = path.join(dependencyPath, 'ios');
+          const androidPath = path.join(dependencyPath, 'android');
+
+          if (fs.existsSync(iosPath) || fs.existsSync(androidPath)) {
+            nativeDependencies.set(name, versions);
+          }
+        }
+      });
+
+      if (nativeDependencies.size > 0) {
+        depsWithNativePeers.set(key, nativeDependencies);
+      }
+    }
+  });
+
+  return depsWithNativePeers;
+}
+
+function filterInstalledPeers(
+  root: string,
+  peers: Map<string, Map<string, string>>,
+) {
+  const data: Record<string, Record<string, string>> = {};
+  const packageJsonPath = path.join(root, 'package.json');
+  const packageJson = require(packageJsonPath);
+  const dependencyList = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies,
+  };
+  peers.forEach((peerDependencies, dependency) => {
+    peerDependencies.forEach((version, name) => {
+      if (!Object.keys(dependencyList).includes(name)) {
+        data[dependency] = {
+          ...data[dependency],
+          [name]: version,
+        };
+      }
+    });
+  });
+
+  return data;
+}
+
+export default async function findPeerDepsForAutolinking(root: string) {
+  const deps = collectDependencies(root);
+  const nonEmptyPeers = filterNativeDependencies(root, deps);
+  const nonInstalledPeers = filterInstalledPeers(root, nonEmptyPeers);
+
+  return nonInstalledPeers;
+}
+
+async function promptForMissingPeerDependencies(
+  dependencies: Record<string, Record<string, string>>,
+): Promise<boolean> {
+  logger.warn(
+    'Looks like you are missing some of the peer dependencies of your libraries:\n',
+  );
+  logger.log(
+    Object.entries(dependencies)
+      .map(
+        ([dependencyName, peerDependencies]) =>
+          `\t${chalk.bold(dependencyName)}:\n ${Object.entries(
+            peerDependencies,
+          ).map(
+            ([peerDependency, peerDependencyVersion]) =>
+              `\t- ${peerDependency} ${peerDependencyVersion}\n`,
+          )}`,
+      )
+      .join('\n')
+      .replace(/,/g, ''),
+  );
+
+  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.',
+  });
+
+  return install;
+}
+
+async function getPackagesVersion(
+  missingDependencies: Record<string, Record<string, string>>,
+) {
+  const packageToRanges: {[pkg: string]: string[]} = {};
+
+  for (const dependency in missingDependencies) {
+    const packages = missingDependencies[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;
+  }
+
+  return workingVersions;
+}
+
+function installMissingPackages(packages: Record<string, string | null>) {
+  const packageVersions = Object.entries(packages).map(
+    ([name, version]) => `${name}@^${version}`,
+  );
+  const flattenList = ([] as string[]).concat(...packageVersions);
+
+  const loader = getLoader({text: 'Installing peer dependencies...'});
+  loader.start();
+  try {
+    execa.sync('npm', ['install', ...flattenList.map((dep) => dep)]);
+    loader.succeed();
+
+    return true;
+  } catch (error) {
+    loader.fail();
+
+    return false;
+  }
+}
+
+export async function resolveTransitiveDeps() {
+  const root = process.cwd();
+
+  const missingPeerDependencies = await findPeerDepsForAutolinking(root);
+
+  if (Object.keys(missingPeerDependencies).length > 0) {
+    const installDeps = await promptForMissingPeerDependencies(
+      missingPeerDependencies,
+    );
+
+    if (installDeps) {
+      const packagesVersions = await getPackagesVersion(
+        missingPeerDependencies,
+      );
+
+      return installMissingPackages(packagesVersions);
+    }
+  }
+
+  return false;
+}
+
+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) {
+    const loader = getLoader({text: 'Installing pods...'});
+    loader.start();
+    await installPods(loader);
+    loader.succeed();
+  }
+}
+
+export async function checkTransitiveDeps() {
+  const packageJsonPath = path.join(process.cwd(), 'package.json');
+  const preInstallHash = generateFileHash(packageJsonPath);
+  const areTransitiveDepsInstalled = await resolveTransitiveDeps();
+  const postInstallHash = generateFileHash(packageJsonPath);
+
+  if (
+    process.platform === 'darwin' &&
+    areTransitiveDepsInstalled &&
+    preInstallHash !== postInstallHash
+  ) {
+    await resolvePodsInstallation();
+  }
+}
diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.ts
@@ -1,5 +1,9 @@
 import loadConfig from '@react-native-community/cli-config';
-import {CLIError, logger} from '@react-native-community/cli-tools';
+import {
+  CLIError,
+  logger,
+  transitiveDeps,
+} from '@react-native-community/cli-tools';
 import type {
   Command,
   Config,
@@ -10,11 +14,6 @@ import childProcess from 'child_process';
 import {Command as CommanderCommand} from 'commander';
 import path from 'path';
 import {detachedCommands, projectCommands} from './commands';
-import installTransitiveDeps, {
-  resolvePodsInstallation,
-} from './tools/resolveTransitiveDeps';
-import {isProjectUsingYarn} from './tools/yarn';
-import generateFileHash from './tools/generateFileHash';
 
 const pkgJson = require('../package.json');
 
@@ -175,19 +174,9 @@ async function setupAndRun() {
       );
     }
   }
-  // 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();
-    }
+
+  if (!transitiveDeps.isUsingYarn(process.cwd())) {
+    await transitiveDeps.checkTransitiveDeps();
   }
 
   let config: Config | undefined;
diff --git a/packages/cli/src/tools/resolveTransitiveDeps.ts b/packages/cli/src/tools/resolveTransitiveDeps.ts
