@bravemobile/react-native-code-push 13.0.0 → 13.1.0-beta.1

package/cli/commands/bundleCommand/bundleCodePush.ts

@@ -4,29 +4,49 @@ import { prepareToBundleJS } from "../../functions/prepareToBundleJS.js";
 import { runReactNativeBundleCommand } from "../../functions/runReactNativeBundleCommand.js";
 import { runExpoBundleCommand } from "../../functions/runExpoBundleCommand.js";
 import { getReactTempDir } from "../../functions/getReactTempDir.js";
-import { runHermesEmitBinaryCommand } from "../../functions/runHermesEmitBinaryCommand.js";
+import { resolveBaseBytecodeHermesFlags, runHermesEmitBinaryCommand } from "../../functions/runHermesEmitBinaryCommand.js";
 import { makeCodePushBundle } from "../../functions/makeCodePushBundle.js";
+import { hashBundleFile, writeBinaryPatchBaseRecord } from "../../functions/makeBinaryPatchBundle.js";
 import { ROOT_OUTPUT_DIR, ENTRY_FILE } from "../../constant.js";
 
+export type CodePushBundleResult = {
+  /** CodePush bundle file name (equals to packageHash) */
+  bundleFileName: string;
+  /** Directory holding the files that were packed into the CodePush bundle file */
+  contentsPath: string;
+  /** JS bundle file name inside the contents directory */
+  jsBundleName: string;
+};
+
 /**
- * @return {Promise<string>} CodePush bundle file name (equals to packageHash)
+ * JS bundle file name react-native writes, which is also the name the app looks for
+ * inside an update, so it has to be decided the same way everywhere.
+ */
+export function resolveJsBundleName(platform: 'ios' | 'android', jsBundleName?: string): string {
+  const DEFAULT_JS_BUNDLE_NAME = platform === 'ios' ? 'main.jsbundle' : 'index.android.bundle';
+  return jsBundleName || DEFAULT_JS_BUNDLE_NAME;
+}
+
+/**
+ * @param baseBundlePath {string} JS bundle from the target binary. When given, the compilation is aligned with it and the base is recorded for a later `release`.
+ * @return {Promise<CodePushBundleResult>} CodePush bundle file name (equals to packageHash) and the contents it was made of
  */
 export async function bundleCodePush(
   framework: 'expo' | undefined,
   platform: 'ios' | 'android' = 'ios',
   outputRootPath: string = ROOT_OUTPUT_DIR,
   entryFile: string = ENTRY_FILE,
-  jsBundleName: string, // JS bundle file name (not CodePush bundle file)
+  jsBundleName: string | undefined, // JS bundle file name (not CodePush bundle file)
   bundleDirectory: string, // CodePush bundle output directory
   outputMetroDir?: string,
-): Promise<string> {
+  baseBundlePath?: string,
+): Promise<CodePushBundleResult> {
     if (fs.existsSync(outputRootPath)) {
         fs.rmSync(outputRootPath, { recursive: true });
     }
 
     const OUTPUT_CONTENT_PATH = `${outputRootPath}/CodePush`;
-    const DEFAULT_JS_BUNDLE_NAME = platform === 'ios' ? 'main.jsbundle' : 'index.android.bundle';
-    const _jsBundleName = jsBundleName || DEFAULT_JS_BUNDLE_NAME; // react-native JS bundle output name
+    const _jsBundleName = resolveJsBundleName(platform, jsBundleName); // react-native JS bundle output name
     const SOURCEMAP_OUTPUT = `${outputRootPath}/${_jsBundleName}.map`;
 
     prepareToBundleJS({ deleteDirs: [outputRootPath, getReactTempDir()], makeDir: OUTPUT_CONTENT_PATH });
@@ -57,13 +77,25 @@ export async function bundleCodePush(
       _jsBundleName,
       OUTPUT_CONTENT_PATH,
       SOURCEMAP_OUTPUT,
+      baseBundlePath ? resolveBaseBytecodeHermesFlags(baseBundlePath) : [],
     );
     console.log('log: Hermes compilation complete');
 
     const { bundleFileName: codePushBundleFileName } = await makeCodePushBundle(OUTPUT_CONTENT_PATH, bundleDirectory);
     console.log(`log: CodePush bundle created (file path: ./${bundleDirectory}/${codePushBundleFileName})`);
 
-    return codePushBundleFileName;
+    if (baseBundlePath) {
+      // Written after the bundle file, and to the output root instead of the update
+      // contents, so recording the base cannot change what was just packed or its hash.
+      const recordPath = writeBinaryPatchBaseRecord(outputRootPath, hashBundleFile(baseBundlePath));
+      console.log(`log: Binary patch base recorded (file path: ${recordPath})`);
+    }
+
+    return {
+      bundleFileName: codePushBundleFileName,
+      contentsPath: OUTPUT_CONTENT_PATH,
+      jsBundleName: _jsBundleName,
+    };
 }
 
 function copyMetroOutputsIfNeeded(

package/cli/commands/bundleCommand/index.ts

@@ -1,5 +1,6 @@
 import { program, Option } from "commander";
 import { bundleCodePush } from "./bundleCodePush.js";
+import { resolveBinaryBundlePathOption } from "../../functions/makeBinaryPatchBundle.js";
 import { OUTPUT_BUNDLE_DIR, ROOT_OUTPUT_DIR, ENTRY_FILE } from "../../constant.js";
 
 type Options = {
@@ -7,9 +8,11 @@ type Options = {
     platform: 'ios' | 'android';
     outputPath: string;
     entryFile: string;
-    bundleName: string;
+    // Commander derives this from the "-b, --bundle-name" flag.
+    bundleName?: string;
     outputBundleDir: string;
     outputMetroDir?: string;
+    binaryBundlePath?: string;
 }
 
 program.command('bundle')
@@ -21,7 +24,11 @@ program.command('bundle')
     .option('-b, --bundle-name <string>', 'bundle file name (default-ios: "main.jsbundle" / default-android: "index.android.bundle")')
     .option('--output-metro-dir <string>', 'name of directory to copy the Metro JS bundle and sourcemap before Hermes compilation')
     .option('--output-bundle-dir <string>', 'name of directory containing the bundle file created by the "bundle" command', OUTPUT_BUNDLE_DIR)
+    .option('--binary-bundle-path <string>', 'path to the JS bundle of the target binary. Aligns the Hermes compilation with it and records it as the binary patch base.')
     .action((options: Options) => {
+        // Resolved before bundling so a wrong path fails now rather than after a build.
+        const baseBundlePath = resolveBinaryBundlePathOption(options.binaryBundlePath);
+
         bundleCodePush(
             options.framework,
             options.platform,
@@ -30,5 +37,6 @@ program.command('bundle')
             options.bundleName,
             `${options.outputPath}/${options.outputBundleDir}`,
             options.outputMetroDir,
+            baseBundlePath,
         )
     });

package/cli/commands/releaseCommand/addToReleaseHistory.ts

@@ -6,6 +6,7 @@ export async function addToReleaseHistory(
     appVersion: string,
     binaryVersion: string,
     bundleDownloadUrl: string,
+    binaryPatchDownloadUrl: string | undefined,
     packageHash: string,
     getReleaseHistory: CliConfigInterface['getReleaseHistory'],
     setReleaseHistory: CliConfigInterface['setReleaseHistory'],
@@ -32,6 +33,12 @@ export async function addToReleaseHistory(
         packageHash: packageHash,
     };
 
+    // A release without a binary patch says nothing about one, so that a client reading
+    // this history downloads the full bundle exactly as it did before patches existed.
+    if (binaryPatchDownloadUrl) {
+        newReleaseHistory[appVersion].binaryPatchDownloadUrl = binaryPatchDownloadUrl;
+    }
+
     if (typeof rollout === 'number') {
         newReleaseHistory[appVersion].rollout = rollout;
     }

package/cli/commands/releaseCommand/index.test.ts

@@ -0,0 +1,118 @@
+import path from "path";
+import { afterEach, beforeEach, describe, expect, it, jest } from "@jest/globals";
+
+/**
+ * Checks the command definition against the arguments it forwards, which is where an
+ * option name can silently drift: commander derives the name it stores from the flag,
+ * so reading a differently named property yields `undefined` for every release rather
+ * than an error, and every downstream default looks as if it had been chosen.
+ */
+
+jest.mock("./release.js");
+jest.mock("../../utils/fsUtils.js", () => ({
+    findAndReadConfigFile: () => ({
+        bundleUploader: async () => ({ downloadUrl: 'https://cdn.example.com/bundle' }),
+        getReleaseHistory: async () => ({}),
+        setReleaseHistory: async () => undefined,
+    }),
+}));
+
+/**
+ * `release()` takes positional arguments; these are the positions this suite asserts on.
+ */
+const ARG_INDEX = {
+    platform: 6,
+    outputPath: 8,
+    entryFile: 9,
+    jsBundleName: 10,
+    skipBundle: 14,
+    bundleDirectory: 16,
+    baseBundlePath: 19,
+    onOversizedPatch: 20,
+} as const;
+
+/**
+ * Parses a `release` invocation against the real command definition. Commander is asked
+ * to throw instead of exiting, and to keep its diagnostics to itself, so a rejected
+ * option can be asserted on without ending the worker or the output.
+ */
+async function parseReleaseCommand(args: string[]): Promise<void> {
+    const { program } = await import("commander");
+    await import("./index.js");
+
+    const releaseCommand = program.commands.find((command) => command.name() === 'release');
+    releaseCommand?.exitOverride();
+    releaseCommand?.configureOutput({ writeErr: () => {} });
+
+    await program.parseAsync(['release', ...args], { from: 'user' });
+}
+
+async function runReleaseCommand(args: string[]): Promise<unknown[]> {
+    const { release } = await import("./release.js");
+
+    await parseReleaseCommand(args);
+
+    const releaseMock = jest.mocked(release);
+    expect(releaseMock).toHaveBeenCalledTimes(1);
+    return releaseMock.mock.calls[0];
+}
+
+beforeEach(() => {
+    jest.resetModules();
+    jest.spyOn(console, 'log').mockImplementation(() => {});
+});
+
+afterEach(() => {
+    jest.restoreAllMocks();
+});
+
+/** Relative to the CLI workspace root, which is where the test runner starts. */
+const BASE_BUNDLE_FIXTURE = 'fixtures/binary-patch/base.bundle';
+
+describe("release command options", () => {
+    it("passes the JS bundle name from -j through to the release", async () => {
+        const args = await runReleaseCommand([
+            '-b', '1.0.0',
+            '-v', '1.0.1',
+            '-p', 'android',
+            '-j', 'custom.jsbundle',
+            '--skip-bundle', 'true',
+            '--binary-bundle-path', BASE_BUNDLE_FIXTURE,
+        ]);
+
+        expect(args[ARG_INDEX.jsBundleName]).toBe('custom.jsbundle');
+        expect(args[ARG_INDEX.platform]).toBe('android');
+        expect(args[ARG_INDEX.skipBundle]).toBe(true);
+        expect(args[ARG_INDEX.baseBundlePath]).toBe(path.resolve(BASE_BUNDLE_FIXTURE));
+    });
+
+    it("leaves the JS bundle name unset when -j is not given, so the platform default applies", async () => {
+        const args = await runReleaseCommand(['-b', '1.0.0', '-v', '1.0.1']);
+
+        expect(args[ARG_INDEX.jsBundleName]).toBeUndefined();
+        expect(args[ARG_INDEX.baseBundlePath]).toBeUndefined();
+        expect(args[ARG_INDEX.outputPath]).toBe('build');
+        expect(args[ARG_INDEX.entryFile]).toBe('index.ts');
+        expect(args[ARG_INDEX.bundleDirectory]).toBe('build/bundleOutput');
+    });
+
+    it("defaults the oversized patch policy to skipping the patch", async () => {
+        const args = await runReleaseCommand(['-b', '1.0.0', '-v', '1.0.1']);
+
+        expect(args[ARG_INDEX.onOversizedPatch]).toBe('skip');
+    });
+
+    it("passes the chosen oversized patch policy through to the release", async () => {
+        const args = await runReleaseCommand(['-b', '1.0.0', '-v', '1.0.1', '--on-oversized-patch', 'fail']);
+
+        expect(args[ARG_INDEX.onOversizedPatch]).toBe('fail');
+    });
+
+    it("rejects an oversized patch policy it does not know", async () => {
+        await expect(parseReleaseCommand(['-b', '1.0.0', '-v', '1.0.1', '--on-oversized-patch', 'ask']))
+            .rejects.toThrow(/--on-oversized-patch.*'ask'.*skip, fail/s);
+
+        const { release } = await import("./release.js");
+        expect(jest.mocked(release)).not.toHaveBeenCalled();
+    });
+});

package/cli/commands/releaseCommand/index.ts

@@ -1,6 +1,12 @@
 import { program, Option } from "commander";
 import { findAndReadConfigFile } from "../../utils/fsUtils.js";
 import { release } from "./release.js";
+import {
+    DEFAULT_OVERSIZED_PATCH_POLICY,
+    OVERSIZED_PATCH_POLICIES,
+    resolveBinaryBundlePathOption,
+    type OversizedPatchPolicy,
+} from "../../functions/makeBinaryPatchBundle.js";
 import { OUTPUT_BUNDLE_DIR, CONFIG_FILE_NAME, ROOT_OUTPUT_DIR, ENTRY_FILE } from "../../constant.js";
 
 type Options = {
@@ -12,7 +18,8 @@ type Options = {
     config: string;
     outputPath: string;
     entryFile: string;
-    bundleName: string;
+    // Commander derives this from the "-j, --js-bundle-name" flag.
+    jsBundleName?: string;
     mandatory: boolean;
     enable: boolean;
     rollout?: number;
@@ -21,6 +28,8 @@ type Options = {
     outputBundleDir: string;
     outputMetroDir?: string;
     hashCalc?: boolean;
+    binaryBundlePath?: string;
+    onOversizedPatch: OversizedPatchPolicy;
 }
 
 program.command('release')
@@ -42,6 +51,10 @@ program.command('release')
     .option('--skip-cleanup <bool>', 'skip cleanup process', parseBoolean, false)
     .option('--output-metro-dir <string>', 'name of directory to copy the Metro JS bundle and sourcemap before Hermes compilation')
     .option('--output-bundle-dir <string>', 'name of directory containing the bundle file created by the "bundle" command', OUTPUT_BUNDLE_DIR)
+    .option('--binary-bundle-path <string>', 'path to the JS bundle of the target binary. Releases an additional binary patch bundle against it, and aligns the Hermes compilation with it.')
+    .addOption(new Option('--on-oversized-patch <policy>', 'what to do when the binary patch bundle is not smaller than the full bundle: "skip" releases the full bundle only, "fail" stops the release before any upload')
+        .choices(OVERSIZED_PATCH_POLICIES)
+        .default(DEFAULT_OVERSIZED_PATCH_POLICY))
     .action(async (options: Options) => {
         const config = findAndReadConfigFile(process.cwd(), options.config);
 
@@ -55,6 +68,9 @@ program.command('release')
             process.exit(1);
         }
 
+        // Resolved before bundling so a wrong path fails now rather than after a build.
+        const baseBundlePath = resolveBinaryBundlePathOption(options.binaryBundlePath);
+
         await release(
             config.bundleUploader,
             config.getReleaseHistory,
@@ -66,7 +82,7 @@ program.command('release')
             options.identifier,
             options.outputPath,
             options.entryFile,
-            options.bundleName,
+            options.jsBundleName,
             options.mandatory,
             options.enable,
             options.rollout,
@@ -75,6 +91,8 @@ program.command('release')
             `${options.outputPath}/${options.outputBundleDir}`,
             options.outputMetroDir,
             options.hashCalc,
+            baseBundlePath,
+            options.onOversizedPatch,
         )
 
         console.log('🚀 Release completed.')