@revopush/code-push-cli 0.0.5 → 0.0.7

package/script/command-executor.ts

@@ -1,35 +1,17 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import AccountManager = require("./management-sdk");
-
 const childProcess = require("child_process");
 import debugCommand from "./commands/debug";
 import * as fs from "fs";
 import * as chalk from "chalk";
-
-const g2js = require("gradle-to-js/lib/parser");
 import * as moment from "moment";
-
-const opener = require("opener");
 import * as os from "os";
 import * as path from "path";
-
-const plist = require("plist");
-const progress = require("progress");
-const prompt = require("prompt");
 import * as Q from "q";
-
-const rimraf = require("rimraf");
 import * as semver from "semver";
-
-const Table = require("cli-table");
-const which = require("which");
-import wordwrap = require("wordwrap");
 import * as cli from "../script/types/cli";
 import sign from "./sign";
-
-const xcode = require("xcode");
 import {
   AccessKey,
   Account,
@@ -45,14 +27,38 @@ import {
   Session,
   UpdateMetrics,
 } from "../script/types";
-import { getAndroidHermesEnabled, getiOSHermesEnabled, runHermesEmitBinaryCommand, isValidVersion } from "./react-native-utils";
-import { fileDoesNotExistOrIsDirectory, isBinaryOrZip, fileExists } from "./utils/file-utils";
+import {
+  getBundleSourceMapOutput,
+  getMinifyParams,
+  getReactNativePackagePath,
+  isHermesEnabled,
+  isValidVersion,
+  runHermesEmitBinaryCommand,
+} from "./react-native-utils";
+import { fileDoesNotExistOrIsDirectory, fileExists, isBinaryOrZip } from "./utils/file-utils";
+
+import AccountManager = require("./management-sdk");
+import wordwrap = require("wordwrap");
+import Promise = Q.Promise;
+
+const g2js = require("gradle-to-js/lib/parser");
+
+const opener = require("opener");
+
+const plist = require("plist");
+const progress = require("progress");
+const prompt = require("prompt");
+
+const rimraf = require("rimraf");
+
+const Table = require("cli-table");
+
+const xcode = require("xcode");
 
 const configFilePath: string = path.join(process.env.LOCALAPPDATA || process.env.HOME, ".revopush.config");
 const emailValidator = require("email-validator");
 const packageJson = require("../../package.json");
 const parseXml = Q.denodeify(require("xml2js").parseString);
-import Promise = Q.Promise;
 
 const properties = require("properties");
 
@@ -1259,6 +1265,7 @@ export const releaseReact = (command: cli.IReleaseReactCommand): Promise<void> =
   let bundleName: string = command.bundleName;
   let entryFile: string = command.entryFile;
   const outputFolder: string = command.outputDir || path.join(os.tmpdir(), "CodePush");
+  const sourcemapOutputFolder: string = command.sourcemapOutput || path.join(os.tmpdir(), "CodePushSourceMap");
   const platform: string = (command.platform = command.platform.toLowerCase());
   const releaseCommand: cli.IReleaseCommand = <any>command;
   // Check for app and deployment exist before releasing an update.
@@ -1266,7 +1273,7 @@ export const releaseReact = (command: cli.IReleaseReactCommand): Promise<void> =
   return (
     sdk
       .getDeployment(command.appName, command.deploymentName)
-      .then((): any => {
+      .then(async () => {
         releaseCommand.package = outputFolder;
 
         switch (platform) {
@@ -1319,8 +1326,9 @@ export const releaseReact = (command: cli.IReleaseReactCommand): Promise<void> =
           ? Q(command.appStoreVersion)
           : getReactNativeProjectAppVersion(command, projectName);
 
-        if (command.sourcemapOutput && !command.sourcemapOutput.endsWith(".map")) {
-          command.sourcemapOutput = path.join(command.sourcemapOutput, bundleName + ".map");
+        if (!sourcemapOutputFolder.endsWith(".map") && !command.sourcemapOutput) {
+          // create tmp dir only if no dir was given by user. User must crete a directory if --sourcemapOutput is passes
+          await createEmptyTempReleaseFolder(sourcemapOutputFolder);
         }
 
         return appVersionPromise;
@@ -1334,29 +1342,28 @@ export const releaseReact = (command: cli.IReleaseReactCommand): Promise<void> =
       // This is needed to clear the react native bundler cache:
       // https://github.com/facebook/react-native/issues/4289
       .then(() => deleteFolder(`${os.tmpdir()}/react-*`))
-      .then(() =>
-        runReactNativeBundleCommand(
+      .then(async () => {
+        await runReactNativeBundleCommand(
+          command,
           bundleName,
           command.development || false,
           entryFile,
           outputFolder,
+          sourcemapOutputFolder,
           platform,
-          command.sourcemapOutput,
           command.extraBundlerOptions
-        )
-      )
+        );
+      })
       .then(async () => {
-        const isHermesEnabled =
-          command.useHermes ||
-          (platform === "android" && (await getAndroidHermesEnabled(command.gradleFile))) || // Check if we have to run hermes to compile JS to Byte Code if Hermes is enabled in build.gradle and we're releasing an Android build
-          (platform === "ios" && (await getiOSHermesEnabled(command.podFile))); // Check if we have to run hermes to compile JS to Byte Code if Hermes is enabled in Podfile and we're releasing an iOS build
+        const isHermes = await isHermesEnabled(command, platform);
 
-        if (isHermesEnabled) {
+        if (isHermes) {
           log(chalk.cyan("\nRunning hermes compiler...\n"));
           await runHermesEmitBinaryCommand(
+            command,
             bundleName,
             outputFolder,
-            command.sourcemapOutput,
+            sourcemapOutputFolder,
             command.extraHermesFlags,
             command.gradleFile
           );
@@ -1374,13 +1381,16 @@ export const releaseReact = (command: cli.IReleaseReactCommand): Promise<void> =
         log(chalk.cyan("\nReleasing update contents to CodePush:\n"));
         return release(releaseCommand);
       })
-      .then(() => {
+      .then(async () => {
         if (!command.outputDir) {
-          deleteFolder(outputFolder);
+          await deleteFolder(outputFolder);
+        }
+
+        if (!command.sourcemapOutput) {
+          await deleteFolder(sourcemapOutputFolder);
         }
       })
-      .catch((err: Error) => {
-        deleteFolder(outputFolder);
+      .catch(async (err: Error) => {
         throw err;
       })
   );
@@ -1427,15 +1437,16 @@ function requestAccessKey(): Promise<string> {
   });
 }
 
-export const runReactNativeBundleCommand = (
+export const runReactNativeBundleCommand = async (
+  command: cli.IReleaseReactCommand,
   bundleName: string,
   development: boolean,
   entryFile: string,
   outputFolder: string,
+  sourcemapOutputFolder: string,
   platform: string,
-  sourcemapOutput: string,
   extraBundlerOptions: string[]
-): Promise<void> => {
+) => {
   const reactNativeBundleArgs: string[] = [];
   const envNodeArgs: string = process.env.CODE_PUSH_NODE_ARGS;
 
@@ -1443,10 +1454,12 @@ export const runReactNativeBundleCommand = (
     Array.prototype.push.apply(reactNativeBundleArgs, envNodeArgs.trim().split(/\s+/));
   }
 
-  const isOldCLI = fs.existsSync(path.join("node_modules", "react-native", "local-cli", "cli.js"));
+  const reactNativePackagePath = getReactNativePackagePath();
+  const oldCliPath = path.join(reactNativePackagePath, "local-cli", "cli.js");
+  const cliPath = fs.existsSync(oldCliPath) ? oldCliPath : path.join(reactNativePackagePath, "cli.js");
 
   Array.prototype.push.apply(reactNativeBundleArgs, [
-    isOldCLI ? path.join("node_modules", "react-native", "local-cli", "cli.js") : path.join("node_modules", "react-native", "cli.js"),
+    cliPath,
     "bundle",
     "--assets-dest",
     outputFolder,
@@ -1458,12 +1471,22 @@ export const runReactNativeBundleCommand = (
     entryFile,
     "--platform",
     platform,
+    "--reset-cache",
   ]);
 
-  if (sourcemapOutput) {
-    reactNativeBundleArgs.push("--sourcemap-output", sourcemapOutput);
+  if (sourcemapOutputFolder) {
+    let bundleSourceMapOutput = sourcemapOutputFolder;
+    if (!sourcemapOutputFolder.endsWith(".map")) {
+      // user defined full path to source map. let's use that instead
+      bundleSourceMapOutput = await getBundleSourceMapOutput(command, bundleName, sourcemapOutputFolder);
+    }
+
+    reactNativeBundleArgs.push("--sourcemap-output", bundleSourceMapOutput);
   }
 
+  const minifyValue = await getMinifyParams(command);
+  Array.prototype.push.apply(reactNativeBundleArgs, minifyValue);
+
   if (extraBundlerOptions.length > 0) {
     reactNativeBundleArgs.push(...extraBundlerOptions);
   }

package/script/react-native-utils.ts

@@ -4,6 +4,9 @@ import * as path from "path";
 import * as childProcess from "child_process";
 import { coerce, compare, valid } from "semver";
 import { fileDoesNotExistOrIsDirectory } from "./utils/file-utils";
+import * as dotenv from "dotenv";
+import { DotenvParseOutput } from "dotenv";
+import * as cli from "../script/types/cli";
 
 const g2js = require("gradle-to-js/lib/parser");
 
@@ -11,12 +14,46 @@ export function isValidVersion(version: string): boolean {
   return !!valid(version) || /^\d+\.\d+$/.test(version);
 }
 
+export async function getBundleSourceMapOutput(command: cli.IReleaseReactCommand, bundleName: string, sourcemapOutputFolder: string) {
+  let bundleSourceMapOutput: string | undefined;
+  switch (command.platform) {
+    case "android": {
+      // see BundleHermesCTask -> resolvePackagerSourceMapFile
+      // for Hermes targeted bundles there are 2 source maps: "packager" (metro) and "compiler" (Hermes)
+      // Metro bundles use <bundleAssetName>.packager.map notation
+      const isHermes = await isHermesEnabled(command, command.platform);
+      if (isHermes) {
+        bundleSourceMapOutput = path.join(sourcemapOutputFolder, bundleName + ".packager.map");
+      } else {
+        bundleSourceMapOutput = path.join(sourcemapOutputFolder, bundleName + ".map");
+      }
+
+      break;
+    }
+    case "ios": {
+      // see react-native-xcode.sh
+      // to match js bundle generated by Xcode and by Revopush cli we must respect SOURCEMAP_FILE value
+      // because it appears as //# sourceMappingURL value in a js bundle
+      const xcodeDotEnvValue = getXcodeDotEnvValue("SOURCEMAP_FILE");
+      const sourceMapFilename = xcodeDotEnvValue ? path.basename(xcodeDotEnvValue) : bundleName + ".map";
+
+      bundleSourceMapOutput = path.join(sourcemapOutputFolder, sourceMapFilename);
+
+      break;
+    }
+    default:
+      throw new Error('Platform must be either "android", "ios" or "windows".');
+  }
+  return bundleSourceMapOutput;
+}
+
 export async function runHermesEmitBinaryCommand(
-    bundleName: string,
-    outputFolder: string,
-    sourcemapOutput: string,
-    extraHermesFlags: string[],
-    gradleFile: string
+  command: cli.IReleaseReactCommand,
+  bundleName: string,
+  outputFolder: string,
+  sourcemapOutputFolder: string,
+  extraHermesFlags: string[],
+  gradleFile: string
 ): Promise<void> {
   const hermesArgs: string[] = [];
   const envNodeArgs: string = process.env.CODE_PUSH_NODE_ARGS;
@@ -27,13 +64,14 @@ export async function runHermesEmitBinaryCommand(
 
   Array.prototype.push.apply(hermesArgs, [
     "-emit-binary",
+    "-O",
     "-out",
     path.join(outputFolder, bundleName + ".hbc"),
     path.join(outputFolder, bundleName),
     ...extraHermesFlags,
   ]);
 
-  if (sourcemapOutput) {
+  if (sourcemapOutputFolder) {
     hermesArgs.push("-output-source-map");
   }
 
@@ -72,8 +110,8 @@ export async function runHermesEmitBinaryCommand(
         });
       });
     });
-  }).then(() => {
-    if (!sourcemapOutput) {
+  }).then(async () => {
+    if (!sourcemapOutputFolder) {
       // skip source map compose if source map is not enabled
       return;
     }
@@ -88,8 +126,33 @@ export async function runHermesEmitBinaryCommand(
       throw new Error(`sourcemap file ${jsCompilerSourceMapFile} is not found`);
     }
 
+    const platformSourceMapOutput = await getBundleSourceMapOutput(command, bundleName, sourcemapOutputFolder);
     return new Promise((resolve, reject) => {
-      const composeSourceMapsArgs = [composeSourceMapsPath, sourcemapOutput, jsCompilerSourceMapFile, "-o", sourcemapOutput];
+      let bundleSourceMapOutput = sourcemapOutputFolder;
+      let combinedSourceMapOutput = sourcemapOutputFolder;
+
+      if (!sourcemapOutputFolder.endsWith(".map")) {
+        bundleSourceMapOutput = platformSourceMapOutput;
+        switch (command.platform) {
+          case "android": {
+            combinedSourceMapOutput = path.join(sourcemapOutputFolder, bundleName + ".map");
+            break;
+          }
+          case "ios": {
+            combinedSourceMapOutput = bundleSourceMapOutput;
+            break;
+          }
+          default:
+            throw new Error('Platform must be either "android", "ios" or "windows".');
+        }
+      }
+      const composeSourceMapsArgs = [
+        composeSourceMapsPath,
+        bundleSourceMapOutput,
+        jsCompilerSourceMapFile,
+        "-o",
+        combinedSourceMapOutput,
+      ];
 
       // https://github.com/facebook/react-native/blob/master/react.gradle#L211
       // https://github.com/facebook/react-native/blob/master/scripts/react-native-xcode.sh#L178
@@ -124,6 +187,40 @@ export async function runHermesEmitBinaryCommand(
   });
 }
 
+export function getXcodeDotEnvValue(key: string): string | undefined {
+  const xcodeEnvs = loadEnvAsMap([path.join("ios", ".xcode.env.local"), path.join("ios", ".xcode.env.local")]);
+  return xcodeEnvs.get(key);
+}
+
+export async function getMinifyParams(command: cli.IReleaseReactCommand) {
+  const isHermes = await isHermesEnabled(command);
+
+  switch (command.platform) {
+    case "android": {
+      // android always explicitly pass --minify true/false
+      // TaskConfiguration        it.minifyEnabled.set(!isHermesEnabledInThisVariant)
+      return ["--minify", !isHermes];
+    }
+    case "ios": {
+      //if [[ $USE_HERMES != false && $DEV == false ]]; then
+      //   EXTRA_ARGS+=("--minify" "false")
+      // fi
+      // ios does pass --minify false only if Hermes enables and does pass anything otherwise
+      return isHermes ? ["--minify", false] : [];
+    }
+    default:
+      throw new Error('Platform must be either "android", "ios" or "windows".');
+  }
+}
+
+export async function isHermesEnabled(command: cli.IReleaseReactCommand, platform: string = command.platform.toLowerCase()) {
+  // Check if we have to run hermes to compile JS to Byte Code if Hermes is enabled in Podfile and we're releasing an iOS build
+  const isAndroidHermesEnabled = await getAndroidHermesEnabled(command.gradleFile);
+  const isIOSHermesEnabled = getiOSHermesEnabled(command.podFile);
+
+  return command.useHermes || (platform === "android" && isAndroidHermesEnabled) || (platform === "ios" && isIOSHermesEnabled);
+}
+
 function parseBuildGradleFile(gradleFile: string) {
   let buildGradlePath: string = path.join("android", "app");
   if (gradleFile) {
@@ -142,6 +239,47 @@ function parseBuildGradleFile(gradleFile: string) {
   });
 }
 
+function parseGradlePropertiesFile(gradleFile: string): Record<string, string> {
+  let gradlePropsPath: string = path.join("android", "gradle.properties");
+
+  try {
+    if (gradleFile) {
+      const base = gradleFile;
+      const stat = fs.lstatSync(base);
+
+      if (stat.isDirectory()) {
+        if (path.basename(base) === "app") {
+          gradlePropsPath = path.join(base, "..", "gradle.properties");
+        } else {
+          gradlePropsPath = path.join(base, "gradle.properties");
+        }
+      } else {
+        gradlePropsPath = path.join(path.dirname(base), "..", "gradle.properties");
+      }
+    }
+  } catch {}
+
+  gradlePropsPath = path.normalize(gradlePropsPath);
+
+  if (fileDoesNotExistOrIsDirectory(gradlePropsPath)) {
+    throw new Error(`Unable to find gradle.properties file "${gradlePropsPath}".`);
+  }
+
+  const text = fs.readFileSync(gradlePropsPath, "utf8");
+  const props: Record<string, string> = {};
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const m = line.match(/^([^=\s]+)\s*=\s*(.*)$/);
+    if (m) {
+      const key = m[1].trim();
+      const val = m[2].trim();
+      props[key] = val;
+    }
+  }
+  return props;
+}
+
 async function getHermesCommandFromGradle(gradleFile: string): Promise<string> {
   const buildGradle: any = await parseBuildGradleFile(gradleFile);
   const hermesCommandProperty: any = Array.from(buildGradle["project.ext.react"] || []).find((prop: string) =>
@@ -154,13 +292,28 @@ async function getHermesCommandFromGradle(gradleFile: string): Promise<string> {
   }
 }
 
-export function getAndroidHermesEnabled(gradleFile: string): boolean {
-  return parseBuildGradleFile(gradleFile).then((buildGradle: any) => {
-    return Array.from(buildGradle["project.ext.react"] || []).some((line: string) => /^enableHermes\s{0,}:\s{0,}true/.test(line));
-  });
+async function getAndroidHermesEnabled(gradleFile: string): Promise<boolean> {
+  try {
+    const props = parseGradlePropertiesFile(gradleFile);
+    if (typeof props.hermesEnabled !== "undefined") {
+      const v = String(props.hermesEnabled).trim().toLowerCase();
+      if (v === "true") return true;
+      if (v === "false") return false;
+    }
+  } catch {}
+
+  try {
+    const buildGradle: any = await parseBuildGradleFile(gradleFile);
+    const lines: string[] = Array.from(buildGradle["project.ext.react"] || []);
+    if (lines.some((l) => /\benableHermes\s*:\s*true\b/.test(l))) return true;
+    if (lines.some((l) => /\benableHermes\s*:\s*false\b/.test(l))) return false;
+  } catch {}
+
+  const rnVersion = coerce(getReactNativeVersion())?.version;
+  return rnVersion && compare(rnVersion, "0.70.0") >= 0;
 }
 
-export function getiOSHermesEnabled(podFile: string): boolean {
+function getiOSHermesEnabled(podFile: string): boolean {
   let podPath = path.join("ios", "Podfile");
   if (podFile) {
     podPath = podFile;
@@ -171,12 +324,33 @@ export function getiOSHermesEnabled(podFile: string): boolean {
 
   try {
     const podFileContents = fs.readFileSync(podPath).toString();
-    return /([^#\n]*:?hermes_enabled(\s+|\n+)?(=>|:)(\s+|\n+)?true)/.test(podFileContents);
+
+    const hasTrue = /([^#\n]*:?hermes_enabled(\s+|\n+)?(=>|:)(\s+|\n+)?true)/.test(podFileContents);
+    if (hasTrue) return true;
+
+    const hasFalse = /([^#\n]*:?hermes_enabled(\s+|\n+)?(=>|:)(\s+|\n+)?false)/.test(podFileContents);
+    if (hasFalse) return false;
+
+    const rnVersion = coerce(getReactNativeVersion())?.version;
+    return rnVersion && compare(rnVersion, "0.70.0") >= 0;
   } catch (error) {
     throw error;
   }
 }
 
+function loadEnvAsMap(envPaths = []): Map<string, string | undefined> {
+  const merged: DotenvParseOutput = {};
+
+  for (const envPath of envPaths) {
+    if (fs.existsSync(envPath)) {
+      Object.assign(merged, dotenv.parse(fs.readFileSync(envPath))); // later files override earlier ones
+    }
+  }
+
+  // fallback to process.env for anything missing
+  return new Map([...Object.entries(process.env), ...Object.entries(merged)]);
+}
+
 function getHermesOSBin(): string {
   switch (process.platform) {
     case "win32":
@@ -211,7 +385,8 @@ async function getHermesCommand(gradleFile: string): Promise<string> {
     }
   };
   // Hermes is bundled with react-native since 0.69
-  const bundledHermesEngine = path.join(getReactNativePackagePath(), "sdks", "hermesc", getHermesOSBin(), getHermesOSExe());
+  const reactNativePath = getReactNativePackagePath();
+  const bundledHermesEngine = path.join(reactNativePath, "sdks", "hermesc", getHermesOSBin(), getHermesOSExe());
   if (fileExists(bundledHermesEngine)) {
     return bundledHermesEngine;
   }
@@ -220,12 +395,14 @@ async function getHermesCommand(gradleFile: string): Promise<string> {
   if (gradleHermesCommand) {
     return path.join("android", "app", gradleHermesCommand.replace("%OS-BIN%", getHermesOSBin()));
   } else {
+    const nodeModulesPath = getNodeModulesPath(reactNativePath);
+
     // assume if hermes-engine exists it should be used instead of hermesvm
-    const hermesEngine = path.join("node_modules", "hermes-engine", getHermesOSBin(), getHermesOSExe());
+    const hermesEngine = path.join(nodeModulesPath, "hermes-engine", getHermesOSBin(), getHermesOSExe());
     if (fileExists(hermesEngine)) {
       return hermesEngine;
     }
-    return path.join("node_modules", "hermesvm", getHermesOSBin(), "hermes");
+    return path.join(nodeModulesPath, "hermesvm", getHermesOSBin(), "hermes");
   }
 }
 
@@ -238,7 +415,16 @@ function getComposeSourceMapsPath(): string {
   return null;
 }
 
-function getReactNativePackagePath(): string {
+function getNodeModulesPath(reactNativePath: string): string {
+ const nodeModulesPath = path.dirname(reactNativePath)
+  if (directoryExistsSync(nodeModulesPath)) {
+    return nodeModulesPath;
+  }
+
+  return path.join("node_modules");
+}
+
+export function getReactNativePackagePath(): string {
   const result = childProcess.spawnSync("node", ["--print", "require.resolve('react-native/package.json')"]);
   const packagePath = path.dirname(result.stdout.toString());
   if (result.status === 0 && directoryExistsSync(packagePath)) {
@@ -280,4 +466,4 @@ export function getReactNativeVersion(): string {
     (projectPackageJson.dependencies && projectPackageJson.dependencies["react-native"]) ||
     (projectPackageJson.devDependencies && projectPackageJson.devDependencies["react-native"])
   );
-}
+}