@bravemobile/react-native-code-push 13.1.0-beta.2 → 13.1.0-beta.4

package/cli/functions/resolveAssetDiffBases.ts

@@ -0,0 +1,108 @@
+/**
+ * Picks the previously released packages a new release builds asset diffs against, and
+ * hands back a verified local copy of each.
+ *
+ * A diff is only installable by a client whose package is byte for byte the base it was
+ * built against, so the base has to be the exact archive the release history describes.
+ * Every download is therefore unpacked and hashed before it is accepted: a base that is
+ * not what the history recorded would produce a diff that sends every client holding
+ * that version into the full-download fallback.
+ *
+ * Bases are the most recent releases, because that is where the installed clients are.
+ * One base failing is never a reason to fail the release - the release still publishes
+ * its full and patch archives, and simply serves fewer diffs.
+ */
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import semver from "semver";
+import { generatePackageHashFromDirectory } from "../utils/hash-utils.js";
+import { extractCodePushBundleContents } from "./makeBinaryPatchBundle.js";
+import type { CliConfigInterface, ReleaseHistoryInterface } from "../../typings/react-native-code-push.d.ts";
+
+const TEMP_DIR_PREFIX = 'codepush-asset-diff-base-';
+
+export type AssetDiffBase = {
+    basePackageHash: string;
+    baseBundleFilePath: string;
+};
+
+/**
+ * @param releaseHistory {ReleaseHistoryInterface} History of the binary version being released to
+ * @param diffBaseCount {number} How many of the most recent releases to build diffs against
+ * @param bundleDownloader Consumer-provided downloader for a released archive
+ * @return The bases that downloaded and verified, newest release first.
+ */
+export async function resolveAssetDiffBases({
+    releaseHistory,
+    diffBaseCount,
+    bundleDownloader,
+    platform,
+    identifier,
+    targetBinaryVersion,
+}: {
+    releaseHistory: ReleaseHistoryInterface;
+    diffBaseCount: number;
+    bundleDownloader: NonNullable<CliConfigInterface['bundleDownloader']>;
+    platform: 'ios' | 'android';
+    identifier?: string;
+    targetBinaryVersion: string;
+}): Promise<AssetDiffBase[]> {
+    // The seeded entry for the update inside the app binary has neither a url nor a hash,
+    // and nothing can be diffed against a package that was never published. A key that is
+    // not a version cannot be ordered against the others either, and ordering is what picks
+    // the recent releases, so it is not eligible.
+    const candidates = Object.entries(releaseHistory)
+        .filter(([version, releaseInfo]) =>
+            Boolean(semver.valid(version)) && Boolean(releaseInfo.downloadUrl) && Boolean(releaseInfo.packageHash))
+        .sort(([left], [right]) => semver.rcompare(left, right))
+        .slice(0, diffBaseCount);
+
+    const bases: AssetDiffBase[] = [];
+    for (const [version, releaseInfo] of candidates) {
+        try {
+            const { downloadedFilePath } = await bundleDownloader({
+                downloadUrl: releaseInfo.downloadUrl,
+                targetBinaryVersion,
+                releaseVersion: version,
+                packageHash: releaseInfo.packageHash,
+            }, platform, identifier);
+
+            if (!(await matchesPackageHash(downloadedFilePath, releaseInfo.packageHash))) {
+                console.warn(
+                    `warn: Skipping the asset diff base v${version}: the downloaded archive does not hash to the ` +
+                        `package hash recorded for it (${releaseInfo.packageHash}).`,
+                );
+                continue;
+            }
+
+            bases.push({ basePackageHash: releaseInfo.packageHash, baseBundleFilePath: downloadedFilePath });
+        } catch (error) {
+            console.warn(
+                `warn: Skipping the asset diff base v${version}: ${error instanceof Error ? error.message : String(error)}`,
+            );
+        }
+    }
+
+    return bases;
+}
+
+/**
+ * Whether an archive holds the contents the release history recorded for it.
+ *
+ * Unpacked into a working directory of its own: the extraction reuses one directory name,
+ * so bases sharing a parent would have the second unpack wipe the first.
+ */
+async function matchesPackageHash(bundleFilePath: string, packageHash: string): Promise<boolean> {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), TEMP_DIR_PREFIX));
+
+    try {
+        const { contentsPath } = await extractCodePushBundleContents(bundleFilePath, tempRoot);
+        // Hashed relative to the contents parent, the way the archive itself was hashed.
+        const actualHash = await generatePackageHashFromDirectory(contentsPath, path.join(contentsPath, '..'));
+        return actualHash === packageHash;
+    } finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}

package/cli/package.json

@@ -12,6 +12,7 @@
   },
   "dependencies": {
     "commander": "^12.1.0",
+    "semver": "^7.3.5",
     "shelljs": "^0.10.0",
     "xcode": "^3.0.1",
     "yazl": "^3.3.1",
@@ -29,6 +30,7 @@
     "node": ">=18"
   },
   "devDependencies": {
+    "@types/semver": "^7.5.8",
     "@types/yazl": "^3.3.0",
     "@types/yauzl": "^2.10.3"
   }

package/cli/utils/zip.ts

@@ -11,6 +11,20 @@ import { walk } from "./promisfied-fs.js";
 type ReleaseFile = { sourceLocation: string, targetLocation: string };
 
 export function zip(updateContentsPath: string): Promise<string> {
+    // For legacy reasons, put the root directory in the zip
+    return zipRelativeTo(updateContentsPath, path.join(updateContentsPath, '..'));
+}
+
+/**
+ * Zips the contents of `rootPath` with entries relative to the root itself, so a file
+ * placed directly under the root lands at the archive root rather than inside a wrapper
+ * directory.
+ */
+export function zipDirectoryContents(rootPath: string): Promise<string> {
+    return zipRelativeTo(rootPath, rootPath);
+}
+
+function zipRelativeTo(updateContentsPath: string, baseDirectoryPath: string): Promise<string> {
 
     // eslint-disable-next-line no-async-promise-executor
     return new Promise(async (resolve, reject) => {
@@ -30,9 +44,6 @@ export function zip(updateContentsPath: string): Promise<string> {
             reject(error);
         }
 
-        const directoryPath = updateContentsPath;
-        const baseDirectoryPath = path.join(directoryPath, '..'); // For legacy reasons, put the root directory in the zip
-
         const files: string[] = await walk(updateContentsPath);
 
         files.forEach((filePath) => {

package/ios/CodePush/CodePushBinaryPatch.m

@@ -40,6 +40,10 @@ static NSString *const BinaryPatchTargetBundleHashKey = @"targetBundleHash";
 static NSString *const BinaryPatchTargetBundleSizeKey = @"targetBundleSize";
 static const NSInteger BinaryPatchFormatVersion = 1;
 
+/* The manifest of the assets to delete that a diff archive carries at its root. Paired
+ * with CodePushPackage.m's DiffManifestFileName, which is file-local there as well. */
+static NSString *const AssetDiffManifestFileName = @"hotcodepush.json";
+
 /*
  * The largest bundle a patch is allowed to promise. A manifest is untrusted input, and
  * the size in it decides how much disk the restore asks for before a single byte of the
@@ -373,21 +377,30 @@ static CodePushBinaryPatchApplyResult CodePushApplyBinaryPatch(const unsigned ch
  * An archive wraps its files in a single directory, and the manifest's paths are
  * relative to that directory rather than to the archive. An archive whose files are at
  * the top level is its own contents root, which is how the tooling that unpacks one
- * reads it too.
+ * reads it too. A diff archive carries the manifest of the assets to delete beside that
+ * wrapper directory, at the root, so that file does not count against the shape.
  */
 + (NSString *)contentsFolderInUnzippedFolder:(NSString *)unzippedFolderPath
 {
-    NSArray *entries = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:unzippedFolderPath
-                                                                          error:nil];
-    if (entries.count == 1) {
-        NSString *entryPath = [unzippedFolderPath stringByAppendingPathComponent:entries.firstObject];
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    NSArray *entries = [fileManager contentsOfDirectoryAtPath:unzippedFolderPath error:nil];
+    NSString *wrapperPath = nil;
+    for (NSString *entry in entries) {
+        NSString *entryPath = [unzippedFolderPath stringByAppendingPathComponent:entry];
         BOOL isDirectory = NO;
-        if ([[NSFileManager defaultManager] fileExistsAtPath:entryPath isDirectory:&isDirectory] && isDirectory) {
-            return entryPath;
+        BOOL exists = [fileManager fileExistsAtPath:entryPath isDirectory:&isDirectory];
+        if (exists && !isDirectory && [entry isEqualToString:AssetDiffManifestFileName]) {
+            continue;
         }
+        if (wrapperPath == nil && exists && isDirectory) {
+            wrapperPath = entryPath;
+            continue;
+        }
+
+        return unzippedFolderPath;
     }
 
-    return unzippedFolderPath;
+    return wrapperPath != nil ? wrapperPath : unzippedFolderPath;
 }
 
 /**

package/ios/CodePush/CodePushPackage.m

@@ -329,8 +329,12 @@ static NSString *const UnzippedFolderName = @"unzipped";
                                                                                                                            error:&error];
                                                             NSArray *deletedFiles = manifestJSON[@"deletedFiles"];
                                                             for (NSString *deletedFileName in deletedFiles) {
-                                                                NSString *absoluteDeletedFilePath = [newUpdateFolderPath stringByAppendingPathComponent:deletedFileName];
-                                                                if ([[NSFileManager defaultManager] fileExistsAtPath:absoluteDeletedFilePath]) {
+                                                                // The manifest is untrusted input, so an entry that reaches outside the
+                                                                // package folder is ignored rather than followed. Whether skipping it
+                                                                // left the update whole is the folder hash check's answer to give.
+                                                                NSString *absoluteDeletedFilePath = [self pathInsideFolder:newUpdateFolderPath
+                                                                                                             relativePath:deletedFileName];
+                                                                if (absoluteDeletedFilePath && [[NSFileManager defaultManager] fileExistsAtPath:absoluteDeletedFilePath]) {
                                                                     [[NSFileManager defaultManager] removeItemAtPath:absoluteDeletedFilePath
                                                                                                                error:&error];
                                                                     if (error) {
@@ -468,6 +472,29 @@ static NSString *const UnzippedFolderName = @"unzipped";
     return [[self getCodePushPath] stringByAppendingPathComponent:BinaryPatchFolderName];
 }
 
+/*
+ * Resolves a path a manifest points at, refusing anything that would reach outside the
+ * folder it is relative to - an archive is untrusted input, and its manifest is no more
+ * trusted than its entries.
+ *
+ * @return the resolved path, or nil when the path is unusable
+ */
++ (NSString *)pathInsideFolder:(NSString *)folderPath
+                  relativePath:(NSString *)relativePath
+{
+    if (relativePath.length == 0 || [relativePath isAbsolutePath]) {
+        return nil;
+    }
+
+    NSString *resolvedFolderPath = [[folderPath stringByStandardizingPath] stringByAppendingString:@"/"];
+    NSString *resolvedPath = [[folderPath stringByAppendingPathComponent:relativePath] stringByStandardizingPath];
+    if (![resolvedPath hasPrefix:resolvedFolderPath]) {
+        return nil;
+    }
+
+    return resolvedPath;
+}
+
 + (NSString *)getCodePushPath
 {
     NSString* codePushPath = [[CodePush getApplicationSupportDirectory] stringByAppendingPathComponent:@"CodePush"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bravemobile/react-native-code-push",
-  "version": "13.1.0-beta.2",
+  "version": "13.1.0-beta.4",
   "description": "React Native plugin for the CodePush service",
   "main": "src/CodePush.js",
   "react-native": "src/CodePush.js",

package/src/CodePush.js

@@ -174,6 +174,12 @@ async function checkForUpdate(handleBinaryVersionMismatchCallback = null) {
         const [latestVersion, latestReleaseInfo] = versioning.findLatestRelease();
         const isMandatory = versioning.checkIsMandatory(runtimeVersion);
 
+        // A diff archive is a patch archive computed against one specific earlier release,
+        // so it only applies when that exact release is the one installed right now.
+        const diffPackageDownloadUrl = localPackage && localPackage.packageHash
+          ? latestReleaseInfo.diffPackages?.[localPackage.packageHash]
+          : undefined;
+
         /**
          * Convert the update information decided from `ReleaseHistoryInterface` to be passed to the library core (original CodePush library).
          *
@@ -185,7 +191,7 @@ async function checkForUpdate(handleBinaryVersionMismatchCallback = null) {
            * Only released updates that were published with a binary patch carry this.
            * When it is missing, the update is downloaded in full from `download_url`.
            */
-          binary_patch_download_url: latestReleaseInfo.binaryPatchDownloadUrl,
+          binary_patch_download_url: diffPackageDownloadUrl || latestReleaseInfo.binaryPatchDownloadUrl,
           // (`enabled` will always be true in the release information obtained from the previous process.)
           is_available: latestReleaseInfo.enabled,
           package_hash: latestReleaseInfo.packageHash,

package/src/CodePush.test.js

@@ -27,6 +27,8 @@ const LABEL = '1.0.1';
 const PACKAGE_HASH = 'a'.repeat(64);
 const DOWNLOAD_URL = 'https://cdn.example.com/full.zip';
 const BINARY_PATCH_DOWNLOAD_URL = 'https://cdn.example.com/full.zip-patch.zip';
+const DIFF_URL = 'https://cdn.example.com/diff-from-base.zip';
+const INSTALLED_HASH = 'base-package-hash';
 
 /** The release the CLI writes when only the full bundle was published. */
 function fullOnlyRelease() {
@@ -50,19 +52,27 @@ function patchedRelease() {
   };
 }
 
+/** The release the CLI writes when the update also has a diff archive against an earlier one. */
+function diffRelease() {
+  const history = patchedRelease();
+  history[LABEL].diffPackages = { [INSTALLED_HASH]: DIFF_URL };
+  return history;
+}
+
 /**
  * @param binaryPatchResult what the native side reports the patch attempt ended in, which
  *        only a download that had a patch to try comes back with.
+ * @param installedPackage the CodePush update the app is running, if any.
  */
-function createNativeBridge({ binaryPatchResult } = {}) {
+function createNativeBridge({ binaryPatchResult, installedPackage } = {}) {
   return {
     addDownloadProgressListener: jest.fn(() => ({ remove: jest.fn() })),
     downloadUpdate: jest.fn(async (updatePackage) => ({
       ...updatePackage,
       ...(binaryPatchResult ? { binaryPatchResult } : {}),
     })),
-    // No CodePush update is installed, so the app runs the bundle of its binary.
-    getUpdateMetadata: jest.fn(async () => null),
+    // Without an installed CodePush update, the app runs the bundle of its binary.
+    getUpdateMetadata: jest.fn(async () => installedPackage ?? null),
     isFailedUpdate: jest.fn(async () => false),
     isFirstRun: jest.fn(async () => false),
     // The rest of what a full `sync()` reaches for.
@@ -82,10 +92,10 @@ function createNativeBridge({ binaryPatchResult } = {}) {
  * @param onBinaryPatchResult a callback the app registers on the decorator, as opposed to
  *        one it passes to a single `sync()` call.
  */
-function loadCodePush({ releaseHistory = {}, updateChecker, binaryPatchResult, onBinaryPatchResult } = {}) {
+function loadCodePush({ releaseHistory = {}, updateChecker, binaryPatchResult, onBinaryPatchResult, installedPackage } = {}) {
   jest.resetModules();
   const CodePush = require('./CodePush');
-  const nativeBridge = createNativeBridge({ binaryPatchResult });
+  const nativeBridge = createNativeBridge({ binaryPatchResult, installedPackage });
 
   CodePush.setUpTestDependencies(
     null,
@@ -200,6 +210,66 @@ describe('checkForUpdate without a binary patch in the release history', () => {
   });
 });
 
+/**
+ * A diff archive only applies to the one release it was computed against, so which of the
+ * two patch urls of a release is downloaded depends on what the app is running right now.
+ */
+describe('checkForUpdate with asset diff packages in the release history', () => {
+  it('downloads the diff archive when the installed update matches a diff base', async () => {
+    const { CodePush, nativeBridge } = loadCodePush({
+      releaseHistory: diffRelease(),
+      installedPackage: { packageHash: INSTALLED_HASH },
+    });
+
+    const remotePackage = await CodePush.checkForUpdate();
+    await remotePackage.download();
+
+    expect(downloadedPackageMetadata(nativeBridge)).toMatchObject({
+      downloadUrl: DOWNLOAD_URL,
+      binaryPatchDownloadUrl: DIFF_URL,
+    });
+  });
+
+  it('downloads the plain patch archive when the installed update matches no diff base', async () => {
+    const { CodePush, nativeBridge } = loadCodePush({
+      releaseHistory: diffRelease(),
+      installedPackage: { packageHash: 'other-hash' },
+    });
+
+    const remotePackage = await CodePush.checkForUpdate();
+    await remotePackage.download();
+
+    expect(downloadedPackageMetadata(nativeBridge)).toMatchObject({
+      binaryPatchDownloadUrl: BINARY_PATCH_DOWNLOAD_URL,
+    });
+  });
+
+  it('downloads the plain patch archive when no update is installed', async () => {
+    const { CodePush, nativeBridge } = loadCodePush({ releaseHistory: diffRelease() });
+
+    const remotePackage = await CodePush.checkForUpdate();
+    await remotePackage.download();
+
+    expect(downloadedPackageMetadata(nativeBridge)).toMatchObject({
+      binaryPatchDownloadUrl: BINARY_PATCH_DOWNLOAD_URL,
+    });
+  });
+
+  it('does not send the diff package map across the bridge', async () => {
+    const { CodePush, nativeBridge } = loadCodePush({
+      releaseHistory: diffRelease(),
+      installedPackage: { packageHash: INSTALLED_HASH },
+    });
+
+    const remotePackage = await CodePush.checkForUpdate();
+    expect(remotePackage).not.toHaveProperty('diffPackages');
+
+    await remotePackage.download();
+
+    expect(downloadedPackageMetadata(nativeBridge)).not.toHaveProperty('diffPackages');
+  });
+});
+
 describe('checkForUpdate through the deprecated updateChecker', () => {
   it('carries the patch url of the update check response', async () => {
     const { CodePush } = loadCodePush({

package/typings/react-native-code-push.d.ts

@@ -34,6 +34,13 @@ export interface ReleaseInfo {
      * that cannot use it downloads the full update from `downloadUrl` instead.
      */
     binaryPatchDownloadUrl?: string;
+    /**
+     * URLs of patch archives that also carry an asset diff, keyed by the packageHash of the
+     * release each archive was diffed against. A client whose installed update matches one of
+     * these keys downloads that archive instead of `binaryPatchDownloadUrl`; every other client
+     * ignores this field. Only present when the release was published with asset diff archives.
+     */
+    diffPackages?: Record<string, string>;
     packageHash: string;
     rollout?: number;
 }
@@ -626,6 +633,31 @@ declare namespace CodePush {
 
 export default CodePush;
 
+/**
+ * Identifies the archive passed to `bundleUploader` during a release.
+ *
+ * `targetBinaryVersion` is the value of the release command's `--binary-version` option.
+ * A full bundle's `packageHash` identifies its contents across target binary versions, while
+ * binary patch and asset diff archives need the target binary version to distinguish their contents.
+ * Asset diff archives also identify the released package they were built against.
+ */
+export type BundleUploadArtifact = {
+    targetBinaryVersion: string;
+    packageHash: string;
+} & (
+    | { type: 'full-bundle' }
+    | { type: 'binary-patch' }
+    | { type: 'asset-diff'; basePackageHash: string }
+);
+
+/** Identifies the previously released full archive passed to `bundleDownloader`. */
+export interface BundleDownloadInfo {
+    downloadUrl: string;
+    targetBinaryVersion: string;
+    releaseVersion: ReleaseVersion;
+    packageHash: string;
+}
+
 /**
  * Interface for the config file required for `npx code-push` CLI operation.
  *
@@ -640,12 +672,14 @@ export interface CliConfigInterface {
      *
      * @param source The relative path of the generated bundle file. (e.g. build/bundleOutput/1087bc338fc45a961c...)
      * @param platform The target platform of the bundle file. This is the string passed when executing the CLI command. ('ios'/'android')
+     * @param artifact Information that identifies the full bundle, binary patch, or asset diff archive. The release command always supplies it; it remains optional so existing callers and three-parameter implementations stay compatible.
      * @return {Promise<{downloadUrl: string}>} An object containing the `downloadUrl` property, which is the URL from which the uploaded bundle file can be downloaded. This URL will be recorded in the release history.
      */
     bundleUploader: (
         source: string,
         platform: "ios" | "android",
         identifier?: string,
+        artifact?: BundleUploadArtifact,
     ) => Promise<{downloadUrl: string}>;
 
     /**
@@ -683,4 +717,19 @@ export interface CliConfigInterface {
         platform: "ios" | "android",
         identifier?: string,
     ) => Promise<void>;
+
+    /**
+     * Downloads a previously released update archive so the release command can compute
+     * asset diffs against it. Receives the `downloadUrl` recorded in the release history and
+     * must resolve with the local path of the downloaded file.
+     * Optional: when absent, releases are published without asset diff archives.
+     *
+     * @param archive Information that identifies the released full archive. The release command
+     * supplies its download URL, target binary version, release version, and package hash together.
+     */
+    bundleDownloader?: (
+        archive: BundleDownloadInfo,
+        platform: "ios" | "android",
+        identifier?: string,
+    ) => Promise<{ downloadedFilePath: string }>;
 }