@revopush/code-push-cli 0.0.5 → 0.0.8-rc.0

package/script/react-native-utils.ts

@@ -3,7 +3,11 @@ import * as chalk from "chalk";
 import * as path from "path";
 import * as childProcess from "child_process";
 import { coerce, compare, valid } from "semver";
-import { fileDoesNotExistOrIsDirectory } from "./utils/file-utils";
+import { downloadBlob, extract, fileDoesNotExistOrIsDirectory } from "./utils/file-utils";
+import * as dotenv from "dotenv";
+import { DotenvParseOutput } from "dotenv";
+import * as cli from "../script/types/cli";
+import { log, sdk } from "./command-executor";
 
 const g2js = require("gradle-to-js/lib/parser");
 
@@ -11,12 +15,70 @@ 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 takeHermesBaseBytecode(
+  command: cli.IReleaseReactCommand,
+  baseReleaseTmpFolder: string,
+  outputFolder: string,
+  bundleName: string
+): Promise<string | null> {
+  const { bundleBlobUrl } = await sdk.getBaseRelease(command.appName, command.deploymentName, command.appStoreVersion);
+  if (!bundleBlobUrl) {
+    return null;
+  }
+
+  const baseReleaseArchive = await downloadBlob(bundleBlobUrl, baseReleaseTmpFolder);
+  await extract(baseReleaseArchive, baseReleaseTmpFolder);
+  const baseReleaseBundle = path.join(baseReleaseTmpFolder, path.basename(outputFolder), bundleName);
+
+  if (!fs.existsSync(baseReleaseBundle)) {
+    log(chalk.cyan("\nNo base release available...\n"));
+    return null;
+  }
+
+  return baseReleaseBundle;
+}
+
 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,
+  baseBytecode?: string
 ): Promise<void> {
   const hermesArgs: string[] = [];
   const envNodeArgs: string = process.env.CODE_PUSH_NODE_ARGS;
@@ -27,16 +89,21 @@ 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");
   }
 
+  if (baseBytecode) {
+    hermesArgs.push("-base-bytecode", baseBytecode);
+  }
+
   console.log(chalk.cyan("Converting JS bundle to byte code via Hermes, running command:\n"));
   const hermesCommand = await getHermesCommand(gradleFile);
   const hermesProcess = childProcess.spawn(hermesCommand, hermesArgs);
@@ -72,8 +139,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 +155,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 +216,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 +268,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 +321,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 +353,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 +414,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 +424,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 +444,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 +495,4 @@ export function getReactNativeVersion(): string {
     (projectPackageJson.dependencies && projectPackageJson.dependencies["react-native"]) ||
     (projectPackageJson.devDependencies && projectPackageJson.devDependencies["react-native"])
   );
-}
+}

package/script/types/cli.ts

@@ -132,6 +132,7 @@ export interface IDeploymentListCommand extends ICommand {
 export interface IDeploymentRemoveCommand extends ICommand {
   appName: string;
   deploymentName: string;
+  isForce?: boolean;
 }
 
 export interface IDeploymentRenameCommand extends ICommand {
@@ -156,6 +157,7 @@ export interface IPackageInfo {
   disabled?: boolean;
   mandatory?: boolean;
   rollout?: number;
+  initial?: boolean;
 }
 
 export interface IPatchCommand extends ICommand, IPackageInfo {
@@ -190,6 +192,7 @@ export interface IReleaseCommand extends IReleaseBaseCommand {
 }
 
 export interface IReleaseReactCommand extends IReleaseBaseCommand {
+  package?: string;
   bundleName?: string;
   development?: boolean;
   entryFile?: string;

package/script/types/rest-definitions.ts

@@ -49,11 +49,18 @@ export interface PackageInfo {
   description?: string;
   isDisabled?: boolean;
   isMandatory?: boolean;
+  isInitial?: boolean;
   /*generated*/ label?: string;
   /*generated*/ packageHash?: string;
   rollout?: number;
 }
 
+/*inout*/
+export interface ReactNativePackageInfo extends PackageInfo {
+  bundleName?: string;
+  outputDir?: string;
+}
+
 /*out*/
 export interface UpdateCheckResponse extends PackageInfo {
   target_binary_range?: string;
@@ -126,6 +133,11 @@ export interface Deployment {
   /*generated*/ package?: Package;
 }
 
+/*inout*/
+export interface BaseRelease {
+  bundleBlobUrl?: string;
+}
+
 /*out*/
 export interface BlobInfo {
   size: number;

package/script/types.ts

@@ -13,6 +13,7 @@ export {
   PackageInfo,
   AccessKey as ServerAccessKey,
   UpdateMetrics,
+  BaseRelease,
 } from "../script/types/rest-definitions";
 
 export interface CodePushError {

package/script/utils/file-utils.ts

@@ -2,6 +2,9 @@ import * as fs from "fs";
 import * as path from "path";
 import * as rimraf from "rimraf";
 import * as temp from "temp";
+import * as unzipper from "unzipper";
+
+import superagent = require("superagent");
 
 export function isBinaryOrZip(path: string): boolean {
   return path.search(/\.zip$/i) !== -1 || path.search(/\.apk$/i) !== -1 || path.search(/\.ipa$/i) !== -1;
@@ -17,7 +20,7 @@ export function fileExists(file: string): boolean {
   } catch (e) {
     return false;
   }
-};
+}
 
 export function copyFileToTmpDir(filePath: string): string {
   if (!isDirectory(filePath)) {
@@ -44,3 +47,29 @@ export function normalizePath(filePath: string): string {
   //replace all backslashes coming from cli running on windows machines by slashes
   return filePath.replace(/\\/g, "/");
 }
+
+export async function downloadBlob(url: string, folder: string, filename: string = "blob.zip"): Promise<string> {
+  const destination = path.join(folder, filename);
+  const writeStream = fs.createWriteStream(destination);
+
+  return new Promise((resolve, reject) => {
+    writeStream.on("finish", () => resolve(destination));
+    writeStream.on("error", reject);
+
+    superagent
+      .get(url)
+      .ok((res) => res.status < 400)
+      .on("error", (err) => {
+        writeStream.destroy();
+        reject(err);
+      })
+      .pipe(writeStream);
+  });
+}
+
+export async function extract(zipPath: string, extractTo: string) {
+  const extractStream = unzipper.Extract({ path: extractTo });
+  await new Promise<void>((resolve, reject) => {
+    fs.createReadStream(zipPath).pipe(extractStream).on("close", resolve).on("error", reject);
+  });
+}

package/test/management-sdk.ts

@@ -196,6 +196,15 @@ describe("Management SDK", () => {
     }, rejectHandler);
   });
 
+  it("getBaseBundle handles JSON response", (done: Mocha.Done) => {
+    mockReturn(JSON.stringify({ basebundle: { bundleBlobUrl: "https://test.test/release.zip" } }), 200, {});
+
+    manager.getBaseRelease("appName", "deploymentName", "1.2.3").done((obj: any) => {
+      assert.ok(obj);
+      done();
+    }, rejectHandler);
+  });
+
   it("getDeployments handles JSON response", (done: Mocha.Done) => {
     mockReturn(JSON.stringify({ deployments: [] }), 200, {});