@rnx-kit/cli 0.12.2 → 0.12.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rnx-kit/cli",
-  "version": "0.12.2",
+  "version": "0.12.5",
   "description": "Command-line interface for working with kit packages in your repo",
   "homepage": "https://github.com/microsoft/rnx-kit/tree/main/packages/cli",
   "license": "MIT",

package/src/copy-assets.ts

@@ -2,7 +2,11 @@ import type { Config as CLIConfig } from "@react-native-community/cli-types";
 import { error, info, warn } from "@rnx-kit/console";
 import { isNonEmptyArray } from "@rnx-kit/tools-language/array";
 import type { PackageManifest } from "@rnx-kit/tools-node/package";
-import { findPackageDir, readPackage } from "@rnx-kit/tools-node/package";
+import {
+  findPackageDependencyDir,
+  findPackageDir,
+  readPackage,
+} from "@rnx-kit/tools-node/package";
 import type { AllPlatforms } from "@rnx-kit/tools-react-native";
 import { parsePlatform } from "@rnx-kit/tools-react-native";
 import { spawnSync } from "child_process";
@@ -11,9 +15,17 @@ import * as os from "os";
 import * as path from "path";
 
 export type AndroidArchive = {
-  targetName: string;
+  targetName?: string;
   version?: string;
   output?: string;
+  android?: {
+    androidPluginVersion?: string;
+    compileSdkVersion?: number;
+    defaultConfig?: {
+      minSdkVersion?: number;
+      targetSdkVersion?: number;
+    };
+  };
 };
 
 export type NativeAssets = {
@@ -44,6 +56,15 @@ export type AssetsConfig = {
   getAssets?: (context: Context) => Promise<NativeAssets>;
 };
 
+const defaultAndroidConfig: Required<Required<AndroidArchive>["android"]> = {
+  androidPluginVersion: "7.1.3",
+  compileSdkVersion: 31,
+  defaultConfig: {
+    minSdkVersion: 23,
+    targetSdkVersion: 29,
+  },
+};
+
 function ensureOption(options: Options, opt: string, flag = opt) {
   if (options[opt] == null) {
     error(`Missing required option: --${flag}`);
@@ -61,6 +82,12 @@ function findGradleProject(projectRoot: string): string | undefined {
   return undefined;
 }
 
+function gradleTargetName(packageName: string): string {
+  return (
+    packageName.startsWith("@") ? packageName.slice(1) : packageName
+  ).replace(/[^\w\-.]+/g, "_");
+}
+
 function isAssetsConfig(config: unknown): config is AssetsConfig {
   return typeof config === "object" && config !== null && "getAssets" in config;
 }
@@ -70,7 +97,12 @@ function keysOf(record: Record<string, unknown> | undefined): string[] {
 }
 
 export function versionOf(pkgName: string): string {
-  const { version } = readPackage(require.resolve(`${pkgName}/package.json`));
+  const packageDir = findPackageDependencyDir(pkgName);
+  if (!packageDir) {
+    throw new Error(`Could not find module '${pkgName}'`);
+  }
+
+  const { version } = readPackage(packageDir);
   return version;
 }
 
@@ -79,13 +111,19 @@ function getAndroidPaths(
   packageName: string,
   { targetName, version, output }: AndroidArchive
 ) {
-  const projectRoot = path.dirname(
-    require.resolve(`${packageName}/package.json`)
-  );
+  const projectRoot = findPackageDependencyDir(packageName);
+  if (!projectRoot) {
+    throw new Error(`Could not find module '${packageName}'`);
+  }
+
+  const gradleFriendlyName = targetName || gradleTargetName(packageName);
+  const aarVersion = version || versionOf(packageName);
 
   switch (packageName) {
     case "hermes-engine":
       return {
+        targetName: gradleFriendlyName,
+        version: aarVersion,
         projectRoot,
         output: path.join(projectRoot, "android", "hermes-release.aar"),
         destination: path.join(
@@ -97,6 +135,8 @@ function getAndroidPaths(
 
     case "react-native":
       return {
+        targetName: gradleFriendlyName,
+        version: aarVersion,
         projectRoot,
         output: path.join(projectRoot, "android"),
         destination: path.join(
@@ -109,6 +149,8 @@ function getAndroidPaths(
     default: {
       const androidProject = findGradleProject(projectRoot);
       return {
+        targetName: gradleFriendlyName,
+        version: aarVersion,
         projectRoot,
         androidProject,
         output:
@@ -119,19 +161,19 @@ function getAndroidPaths(
               "build",
               "outputs",
               "aar",
-              `${targetName}-release.aar`
+              `${gradleFriendlyName}-release.aar`
             )),
         destination: path.join(
           context.options.assetsDest,
           "aar",
-          `${targetName}-${version || versionOf(packageName)}.aar`
+          `${gradleFriendlyName}-${aarVersion}.aar`
         ),
       };
     }
   }
 }
 
-async function assembleAarBundle(
+export async function assembleAarBundle(
   context: Context,
   packageName: string,
   { aar }: NativeAssets
@@ -149,55 +191,136 @@ async function assembleAarBundle(
     return;
   }
 
-  const { androidProject, output } = getAndroidPaths(context, packageName, aar);
+  const { targetName, version, androidProject, output } = getAndroidPaths(
+    context,
+    packageName,
+    aar
+  );
   if (!androidProject || !output) {
     warn(`Skipped \`${packageName}\`: cannot find \`build.gradle\``);
     return;
   }
 
-  const { targetName, version, env, dependencies } = aar;
+  const { env: customEnv, dependencies, android } = aar;
+  const env = {
+    NODE_MODULES_PATH: path.join(process.cwd(), "node_modules"),
+    REACT_NATIVE_VERSION: versionOf("react-native"),
+    ...process.env,
+    ...customEnv,
+  };
+
+  const outputDir = path.join(context.options.assetsDest, "aar");
+  await fs.ensureDir(outputDir);
+
+  const dest = path.join(outputDir, `${targetName}-${version}.aar`);
+
   const targets = [`:${targetName}:assembleRelease`];
-  const targetsToCopy: [string, string][] = [];
-  if (dependencies) {
-    for (const [dependencyName, aar] of Object.entries(dependencies)) {
-      const { output, destination } = getAndroidPaths(
-        context,
-        dependencyName,
-        aar
-      );
-      if (output) {
-        if (!fs.existsSync(output)) {
-          targets.push(`:${aar.targetName}:assembleRelease`);
-          targetsToCopy.push([output, destination]);
-        } else if (!fs.existsSync(destination)) {
-          targetsToCopy.push([output, destination]);
+  const targetsToCopy: [string, string][] = [[output, dest]];
+
+  const settings = path.join(androidProject, "settings.gradle");
+  if (fs.existsSync(settings)) {
+    if (dependencies) {
+      for (const [dependencyName, aar] of Object.entries(dependencies)) {
+        const { targetName, output, destination } = getAndroidPaths(
+          context,
+          dependencyName,
+          aar
+        );
+        if (output) {
+          if (!fs.existsSync(output)) {
+            targets.push(`:${targetName}:assembleRelease`);
+            targetsToCopy.push([output, destination]);
+          } else if (!fs.existsSync(destination)) {
+            targetsToCopy.push([output, destination]);
+          }
         }
       }
     }
-  }
 
-  // Run only one Gradle task at a time
-  spawnSync(gradlew, targets, {
-    cwd: androidProject,
-    stdio: "inherit",
-    env: {
-      ENABLE_HERMES: "true",
-      NODE_MODULES_PATH: path.join(process.cwd(), "node_modules"),
-      REACT_NATIVE_VERSION: versionOf("react-native"),
-      ...process.env,
-      ...env,
-    },
-  });
+    // Run only one Gradle task at a time
+    spawnSync(gradlew, targets, { cwd: androidProject, stdio: "inherit", env });
+  } else {
+    const reactNativePath = findPackageDependencyDir("react-native");
+    if (!reactNativePath) {
+      throw new Error("Could not find 'react-native'");
+    }
 
-  const destination = path.join(context.options.assetsDest, "aar");
-  await fs.ensureDir(destination);
+    const buildDir = path.join(
+      process.cwd(),
+      "node_modules",
+      ".rnx-gradle-build",
+      targetName
+    );
+
+    const compileSdkVersion =
+      android?.compileSdkVersion ?? defaultAndroidConfig.compileSdkVersion;
+    const minSdkVersion =
+      android?.defaultConfig?.minSdkVersion ??
+      defaultAndroidConfig.defaultConfig.minSdkVersion;
+    const targetSdkVersion =
+      android?.defaultConfig?.targetSdkVersion ??
+      defaultAndroidConfig.defaultConfig.targetSdkVersion;
+    const androidPluginVersion =
+      android?.androidPluginVersion ??
+      defaultAndroidConfig.androidPluginVersion;
+    const buildRelativeReactNativePath = path.relative(
+      buildDir,
+      reactNativePath
+    );
+
+    const buildGradle = [
+      "buildscript {",
+      "  ext {",
+      `      compileSdkVersion = ${compileSdkVersion}`,
+      `      minSdkVersion = ${minSdkVersion}`,
+      `      targetSdkVersion = ${targetSdkVersion}`,
+      `      androidPluginVersion = "${androidPluginVersion}"`,
+      "  }",
+      "",
+      "  repositories {",
+      "      mavenCentral()",
+      "      google()",
+      "  }",
+      "",
+      "  dependencies {",
+      '      classpath("com.android.tools.build:gradle:${project.ext.androidPluginVersion}")',
+      "  }",
+      "}",
+      "",
+      "allprojects {",
+      "  repositories {",
+      "      maven {",
+      "          // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm",
+      `          url("\${rootDir}/${buildRelativeReactNativePath}/android")`,
+      "      }",
+      "      mavenCentral()",
+      "      google()",
+      "  }",
+      "}",
+      "",
+    ].join("\n");
+
+    const gradleProperties = "android.useAndroidX=true\n";
+
+    const settingsGradle = [
+      `include(":${targetName}")`,
+      `project(":${targetName}").projectDir = file("${androidProject}")`,
+      "",
+    ].join("\n");
+
+    await fs.ensureDir(buildDir);
+    await fs.writeFile(path.join(buildDir, "build.gradle"), buildGradle);
+    await fs.writeFile(
+      path.join(buildDir, "gradle.properties"),
+      gradleProperties
+    );
+    await fs.writeFile(path.join(buildDir, "settings.gradle"), settingsGradle);
+
+    // Run only one Gradle task at a time
+    spawnSync(gradlew, targets, { cwd: buildDir, stdio: "inherit", env });
+  }
 
-  const aarVersion = version || versionOf(packageName);
-  const dest = path.join(destination, `${targetName}-${aarVersion}.aar`);
-  await Promise.all([
-    fs.copy(output, dest),
-    ...targetsToCopy.map(([src, dest]) => fs.copy(src, dest)),
-  ]);
+  await Promise.all(targetsToCopy.map(([src, dest]) => fs.copy(src, dest)));
 }
 
 async function copyFiles(files: unknown, destination: string): Promise<void> {

package/src/metro-config.ts

@@ -62,22 +62,28 @@ function createSerializerHook(options: TypeScriptValidationOptions) {
         excludeNodeModules
       );
 
-      //  Map each file to a TypeScript project, and apply its delta operation.
+      //  Try to map each file to a TypeScript project, and apply its delta operation.
+      //  Some projects may not actually be TypeScript projects (ignore those).
       const tsprojectsToValidate: Set<Project> = new Set();
       adds.concat(updates).forEach((sourceFile) => {
-        const { tsproject, tssourceFiles } = projectCache.getProjectInfo(
-          sourceFile,
-          platform
-        );
-        if (tssourceFiles.has(sourceFile)) {
-          tsproject.setFile(sourceFile);
-          tsprojectsToValidate.add(tsproject);
+        const projectInfo = projectCache.getProjectInfo(sourceFile, platform);
+        if (projectInfo) {
+          // This is a TypeScript project. Validate it.
+          const { tsproject, tssourceFiles } = projectInfo;
+          if (tssourceFiles.has(sourceFile)) {
+            tsproject.setFile(sourceFile);
+            tsprojectsToValidate.add(tsproject);
+          }
         }
       });
       deletes.forEach((sourceFile) => {
-        const { tsproject } = projectCache.getProjectInfo(sourceFile, platform);
-        tsproject.removeFile(sourceFile);
-        tsprojectsToValidate.add(tsproject);
+        const projectInfo = projectCache.getProjectInfo(sourceFile, platform);
+        if (projectInfo) {
+          // This is a TypeScript project. Validate it.
+          const { tsproject } = projectInfo;
+          tsproject.removeFile(sourceFile);
+          tsprojectsToValidate.add(tsproject);
+        }
       });
 
       //  Validate all projects which changed, printing all type errors.

package/src/start.ts

@@ -17,6 +17,19 @@ import { customizeMetroConfig } from "./metro-config";
 import { getKitServerConfig } from "./serve/kit-config";
 import type { TypeScriptValidationOptions } from "./types";
 
+type DevServerMiddleware = ReturnType<
+  typeof CliServerApi["createDevServerMiddleware"]
+>;
+
+type DevServer = ReturnType<DevServerMiddleware["attachToServer"]>;
+
+type DevServerMiddleware7 = Pick<DevServerMiddleware, "middleware"> & {
+  websocketEndpoints: unknown;
+  debuggerProxyEndpoint: DevServer["debuggerProxy"];
+  messageSocketEndpoint: DevServer["messageSocket"];
+  eventsSocketEndpoint: DevServer["eventsSocket"];
+};
+
 export type CLIStartOptions = {
   host: string;
   port: number;
@@ -44,6 +57,12 @@ function friendlyRequire<T>(module: string): T {
   }
 }
 
+function hasWebsocketEndpoints(
+  devServer: DevServerMiddleware | DevServerMiddleware7
+): devServer is DevServerMiddleware7 {
+  return !("attachToServer" in devServer);
+}
+
 export async function rnxStart(
   _argv: Array<string>,
   cliConfig: CLIConfig,
@@ -136,11 +155,12 @@ export async function rnxStart(
 
   // create middleware -- a collection of plugins which handle incoming
   // http(s) requests, routing them to static pages or JS functions.
-  const { middleware, attachToServer } = createDevServerMiddleware({
+  const devServer = createDevServerMiddleware({
     host: cliOptions.host,
     port: metroConfig.server.port,
     watchFolders: metroConfig.watchFolders,
   });
+  const middleware = devServer.middleware;
   middleware.use(indexPageMiddleware);
 
   // merge the Metro config middleware with our middleware
@@ -158,17 +178,37 @@ export async function rnxStart(
     );
   };
 
+  // `createDevServerMiddleware` changed its return type in
+  // https://github.com/react-native-community/cli/pull/1560
+  let websocketEndpoints: unknown = undefined;
+  let messageSocketEndpoint: DevServer["messageSocket"];
+
+  if (hasWebsocketEndpoints(devServer)) {
+    websocketEndpoints = devServer.websocketEndpoints;
+    messageSocketEndpoint = devServer.messageSocketEndpoint;
+
+    // bind our `reportEvent` delegate to the Metro server
+    reportEventDelegate = devServer.eventsSocketEndpoint.reportEvent;
+  }
+
   // start the Metro server
-  const serverInstance = await startServer(metroConfig, {
+  const serverOptions = {
     host: cliOptions.host,
     secure: cliOptions.https,
     secureCert: cliOptions.cert,
     secureKey: cliOptions.key,
-  });
-  const { messageSocket, eventsSocket } = attachToServer(serverInstance);
+    websocketEndpoints,
+  };
+  const serverInstance = await startServer(metroConfig, serverOptions);
+
+  if (!hasWebsocketEndpoints(devServer)) {
+    const { messageSocket, eventsSocket } =
+      devServer.attachToServer(serverInstance);
+    messageSocketEndpoint = messageSocket;
 
-  // bind our `reportEvent` delegate to the Metro server
-  reportEventDelegate = eventsSocket.reportEvent;
+    // bind our `reportEvent` delegate to the Metro server
+    reportEventDelegate = eventsSocket.reportEvent;
+  }
 
   // In Node 8, the default keep-alive for an HTTP connection is 5 seconds. In
   // early versions of Node 8, this was implemented in a buggy way which caused
@@ -217,12 +257,12 @@ export async function rnxStart(
 
           case "d":
             terminal.log(chalk.green("Opening developer menu..."));
-            messageSocket.broadcast("devMenu", undefined);
+            messageSocketEndpoint.broadcast("devMenu", undefined);
             break;
 
           case "r":
             terminal.log(chalk.green("Reloading app..."));
-            messageSocket.broadcast("reload", undefined);
+            messageSocketEndpoint.broadcast("reload", undefined);
             break;
         }
       }

package/src/test.ts

@@ -1,7 +1,7 @@
 import type { Config as CLIConfig } from "@react-native-community/cli-types";
+import { findPackageDependencyDir } from "@rnx-kit/tools-node";
 import { parsePlatform } from "@rnx-kit/tools-react-native/platform";
 import { run as runJest } from "jest-cli";
-import path from "path";
 
 type Args = {
   platform: "android" | "ios" | "macos" | "windows" | "win32";
@@ -54,8 +54,8 @@ function jestOptions(): Options[] {
   //
   // To work around this, resolve `jest-cli` first, then use the resolved path
   // to import `./build/cli/args`.
-  const jestPath = require.resolve("jest-cli/package.json");
-  const { options } = require(`${path.dirname(jestPath)}/build/cli/args`);
+  const jestPath = findPackageDependencyDir("jest-cli") || "jest-cli";
+  const { options } = require(`${jestPath}/build/cli/args`);
 
   return Object.keys(options).map((option) => {
     const { default: defaultValue, description, type } = options[option];

package/src/typescript/project-cache.ts

@@ -9,6 +9,7 @@ import {
   Project,
   readConfigFile,
 } from "@rnx-kit/typescript-service";
+import fs from "fs";
 import path from "path";
 import ts from "typescript";
 
@@ -44,7 +45,10 @@ export interface ProjectCache {
    * @param sourceFile Source file
    * @returns Project targeting the given platform and containing the given source file
    */
-  getProjectInfo(sourceFile: string, platform: AllPlatforms): ProjectInfo;
+  getProjectInfo(
+    sourceFile: string,
+    platform: AllPlatforms
+  ): ProjectInfo | undefined;
 }
 
 /**
@@ -84,8 +88,19 @@ export function createProjectCache(
     return root;
   }
 
-  function readTSConfig(root: string): ts.ParsedCommandLine {
+  function readTSConfig(root: string): ts.ParsedCommandLine | undefined {
     const configFileName = path.join(root, "tsconfig.json");
+    if (!fs.existsSync(configFileName)) {
+      // Allow for packages that aren't TypeScript.
+      //
+      // Example: Users who enable bundling with all the config defaults will
+      // have type validation enabled automatically. They may not actually be
+      // using TypeScript.
+      //
+      // We shouldn't break them. We should use TS validation only for TS packages.
+      //
+      return undefined;
+    }
 
     const cmdLine = readConfigFile(configFileName);
     if (!cmdLine) {
@@ -102,9 +117,13 @@ export function createProjectCache(
   function createProjectInfo(
     root: string,
     platform: AllPlatforms
-  ): ProjectInfo {
+  ): ProjectInfo | undefined {
     // Load the TypeScript configuration file for this project.
     const cmdLine = readTSConfig(root);
+    if (!cmdLine) {
+      // Not a TypeScript project
+      return undefined;
+    }
 
     //  Trim down the list of source files found by TypeScript. This ensures
     //  that only explicitly added files are loaded and parsed by TypeScript.
@@ -151,15 +170,23 @@ export function createProjectCache(
   function getProjectInfo(
     sourceFile: string,
     platform: AllPlatforms
-  ): ProjectInfo {
+  ): ProjectInfo | undefined {
     const root = findProjectRoot(sourceFile);
     projects[root] ||= {};
 
-    let info = projects[root][platform];
-    if (!info) {
-      info = createProjectInfo(root, platform);
-      projects[root][platform] = info;
+    const platforms = projects[root];
+
+    // Have we seen the project/platform for this source file before,
+    // even if what we saw is 'undefined' (e.g. not a TS project)?
+    if (Object.prototype.hasOwnProperty.call(platforms, platform)) {
+      return platforms[platform];
     }
+
+    // We haven't seen this project/platform before. Try to load it,
+    // even if it isn't a TS project. Cache the result so we don't
+    // do this again.
+    const info = createProjectInfo(root, platform);
+    platforms[platform] = info;
     return info;
   }
 

package/test/__mocks__/child_process.js

@@ -0,0 +1,5 @@
+const child_process = jest.createMockFromModule("child_process");
+
+child_process.spawnSync(() => undefined);
+
+module.exports = child_process;

package/test/__mocks__/fs-extra.js

@@ -14,7 +14,9 @@ fs.__toJSON = () => vol.toJSON();
 
 fs.copy = (...args) => vol.promises.copyFile(...args);
 fs.ensureDir = (dir) => vol.promises.mkdir(dir, { recursive: true });
+fs.existsSync = (...args) => vol.existsSync(...args);
 fs.pathExists = (...args) => Promise.resolve(vol.existsSync(...args));
 fs.readFile = (...args) => vol.promises.readFile(...args);
+fs.writeFile = (...args) => vol.promises.writeFile(...args);
 
 module.exports = fs;

package/test/__mocks__/fs.js

@@ -0,0 +1,19 @@
+const fs = jest.createMockFromModule("fs");
+
+const { vol } = require("memfs");
+
+/** @type {(newMockFiles: { [filename: string]: string }) => void} */
+fs.__setMockFiles = (files) => {
+  vol.reset();
+  vol.fromJSON(files);
+};
+
+fs.__toJSON = () => vol.toJSON();
+
+fs.lstat = (...args) => Promise.resolve(vol.lstat(...args));
+fs.lstatSync = (...args) => vol.lstatSync(...args);
+fs.readFileSync = (...args) => vol.readFileSync(...args);
+fs.stat = (...args) => Promise.resolve(vol.stat(...args));
+fs.statSync = (...args) => vol.statSync(...args);
+
+module.exports = fs;