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

package/README.md

@@ -351,9 +351,10 @@ Diff archives are published only when all three of these hold:
 - `--diff-base-count` is greater than `0` (it defaults to `3`).
 
 ```ts
-bundleDownloader: async (downloadUrl) => {
-    const downloadedFilePath = path.join(os.tmpdir(), path.basename(new URL(downloadUrl).pathname));
-    // fetch the archive from your storage (S3, GCS, ...) to downloadedFilePath
+bundleDownloader: async (archive, platform, identifier = 'staging') => {
+    const downloadedFilePath = path.join(os.tmpdir(), archive.packageHash);
+    const storageKey = `bundles/${platform}/${identifier}/full-bundle/${archive.packageHash}`;
+    // fetch storageKey from your storage (S3, Supabase, ...) to downloadedFilePath
     return { downloadedFilePath };
 },
 ```
@@ -389,6 +390,7 @@ const Config: CliConfigInterface = {
     source: string,
     platform: "ios" | "android",
     identifier,
+    artifact,
   ): Promise<{downloadUrl: string}> => {
     // ...
   },
@@ -413,7 +415,7 @@ const Config: CliConfigInterface = {
 
   // Only needed to publish asset diff archives (see "4-2. Asset Diff Archives").
   // bundleDownloader: async (
-  //   downloadUrl: string,
+  //   archive,
   //   platform: "ios" | "android",
   //   identifier,
   // ): Promise<{downloadedFilePath: string}> => {
@@ -427,6 +429,9 @@ module.exports = Config;
 
 **`bundleUploader`**
 - Implements a function to upload the bundle file.
+- The optional `artifact` argument identifies the full bundle, binary patch, or asset diff
+  archive. The `release` command always provides it, including the target binary version and
+  the package hashes needed to construct a storage key without parsing a file name.
 - The `downloadUrl` returned by this function is recorded in `ReleaseHistoryInterface` data
   and is used by the library runtime to download the bundle file from this URL.
 - Used in the following cases:

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

@@ -17,7 +17,7 @@ import {
 import { applyPatch } from "../../utils/binaryPatch.js";
 import { generatePackageHashFromDirectory } from "../../utils/hash-utils.js";
 import { unzip } from "../../utils/unzip.js";
-import type { CliConfigInterface, ReleaseHistoryInterface } from "../../../typings/react-native-code-push.d.ts";
+import type { BundleUploadArtifact, CliConfigInterface, ReleaseHistoryInterface } from "../../../typings/react-native-code-push.d.ts";
 
 /**
  * Covers the release flow around the binary patch option with `--skip-bundle`, which is
@@ -92,15 +92,23 @@ class ProcessExitError extends Error {
     }
 }
 
-type Uploads = { filePath: string, downloadUrl: string, logCountBeforeUpload: number }[];
-
-function recordingUploader(uploads: Uploads, failOn?: (filePath: string) => boolean) {
-    return async (filePath: string) => {
+type Uploads = {
+    artifact: BundleUploadArtifact | undefined;
+    downloadUrl: string;
+    filePath: string;
+    logCountBeforeUpload: number;
+}[];
+
+function recordingUploader(
+    uploads: Uploads,
+    failOn?: (filePath: string) => boolean,
+): CliConfigInterface['bundleUploader'] {
+    return async (filePath, _platform, _identifier, artifact) => {
         if (failOn?.(filePath)) {
             throw new Error(`upload rejected: ${path.basename(filePath)}`);
         }
         const downloadUrl = `https://cdn.example.com/${path.basename(filePath)}`;
-        uploads.push({ filePath, downloadUrl, logCountBeforeUpload: logs.length });
+        uploads.push({ artifact, filePath, downloadUrl, logCountBeforeUpload: logs.length });
         return { downloadUrl };
     };
 }
@@ -204,6 +212,17 @@ afterEach(() => {
 });
 
 describe("release without --binary-bundle-path", () => {
+    it("keeps existing three-argument uploaders callable", async () => {
+        const legacyUploader = async (
+            source: string,
+            _platform: 'ios' | 'android',
+            _identifier?: string,
+        ) => ({ downloadUrl: source });
+        const uploader: CliConfigInterface['bundleUploader'] = legacyUploader;
+
+        await expect(uploader('bundle.zip', 'ios')).resolves.toEqual({ downloadUrl: 'bundle.zip' });
+    });
+
     it("uploads the full bundle only, exactly as before binary patches existed", async () => {
         const staged = await stageBundleOutput("full-only");
 
@@ -211,6 +230,11 @@ describe("release without --binary-bundle-path", () => {
 
         expect(uploads).toHaveLength(1);
         expect(uploads[0].filePath).toBe(`${staged.bundleDirectory}/${staged.bundleFileName}`);
+        expect(uploads[0].artifact).toEqual({
+            type: 'full-bundle',
+            targetBinaryVersion: BINARY_VERSION,
+            packageHash: staged.bundleFileName,
+        });
         expect(fs.readdirSync(staged.bundleDirectory)).toEqual([staged.bundleFileName]);
         expect(releaseHistories[0][APP_VERSION]).toEqual({
             enabled: true,
@@ -658,11 +682,11 @@ describe("release with asset diff bases", () => {
 
     /** Serves the staged base archives, and records which releases were asked for. */
     function recordingDownloader(bases: StagedBaseRelease[], downloads: string[]): CliConfigInterface['bundleDownloader'] {
-        return async (downloadUrl: string) => {
-            downloads.push(downloadUrl);
-            const base = bases.find((candidate) => candidate.downloadUrl === downloadUrl);
+        return async (archive) => {
+            downloads.push(archive.downloadUrl);
+            const base = bases.find((candidate) => candidate.downloadUrl === archive.downloadUrl);
             if (!base) {
-                throw new Error(`the downloader was called with an unexpected url: ${downloadUrl}`);
+                throw new Error(`the downloader was called with an unexpected url: ${archive.downloadUrl}`);
             }
             return { downloadedFilePath: base.archivePath };
         };
@@ -687,6 +711,24 @@ describe("release with asset diff bases", () => {
             `${staged.bundleFileName}${BINARY_PATCH_ARCHIVE_SUFFIX}`,
             diffFileName,
         ]);
+        expect(uploads.map(({ artifact }) => artifact)).toEqual([
+            {
+                type: 'full-bundle',
+                targetBinaryVersion: BINARY_VERSION,
+                packageHash: staged.bundleFileName,
+            },
+            {
+                type: 'binary-patch',
+                targetBinaryVersion: BINARY_VERSION,
+                packageHash: staged.bundleFileName,
+            },
+            {
+                type: 'asset-diff',
+                targetBinaryVersion: BINARY_VERSION,
+                packageHash: staged.bundleFileName,
+                basePackageHash: base.packageHash,
+            },
+        ]);
         expect(downloads).toEqual([base.downloadUrl]);
         // Every artifact is uploaded before the history points at any of them.
         expect(uploadCountsWhenHistorySaved).toEqual([3]);

package/cli/commands/releaseCommand/release.ts

@@ -2,7 +2,7 @@ import fs from "fs";
 import path from "path";
 import { bundleCodePush, resolveJsBundleName } from "../bundleCommand/bundleCodePush.js";
 import { addToReleaseHistory } from "./addToReleaseHistory.js";
-import type { CliConfigInterface, ReleaseHistoryInterface } from "../../../typings/react-native-code-push.d.ts";
+import type { BundleUploadArtifact, CliConfigInterface, ReleaseHistoryInterface } from "../../../typings/react-native-code-push.d.ts";
 import { generatePackageHashFromDirectory } from "../../utils/hash-utils.js";
 import { unzip } from "../../utils/unzip.js";
 import { ASSET_DIFF_ARCHIVE_INFIX, makeAssetDiffBundle } from "../../functions/makeAssetDiffBundle.js";
@@ -95,6 +95,7 @@ export async function release(
             bundleDownloader,
             bundleDirectory,
             packageHash,
+            targetBinaryVersion: binaryVersion,
             platform,
             identifier,
         })
@@ -102,10 +103,32 @@ export async function release(
 
     // Every artifact is uploaded before the release history is touched, so a failed
     // upload leaves the history describing only updates that can actually be downloaded.
-    const downloadUrl = await uploadArtifact(bundleUploader, bundleFilePath, platform, identifier, 'bundle');
+    const downloadUrl = await uploadArtifact(
+        bundleUploader,
+        bundleFilePath,
+        platform,
+        identifier,
+        {
+            type: 'full-bundle',
+            targetBinaryVersion: binaryVersion,
+            packageHash,
+        },
+        'bundle',
+    );
     let patchDownloadUrl: string | undefined;
     if (binaryPatch) {
-        patchDownloadUrl = await uploadArtifact(bundleUploader, binaryPatch.patchBundleFilePath, platform, identifier, 'binary patch bundle');
+        patchDownloadUrl = await uploadArtifact(
+            bundleUploader,
+            binaryPatch.patchBundleFilePath,
+            platform,
+            identifier,
+            {
+                type: 'binary-patch',
+                targetBinaryVersion: binaryVersion,
+                packageHash,
+            },
+            'binary patch bundle',
+        );
         console.log(`log: Binary patch archive uploaded (download url: ${patchDownloadUrl})`);
     }
     const diffPackages: Record<string, string> = {};
@@ -114,7 +137,12 @@ export async function release(
         // one that cannot be uploaded is left out of the history instead of failing the
         // release the other two artifacts are ready for.
         try {
-            const diffDownloadUrl = await uploadFile(bundleUploader, filePath, platform, identifier);
+            const diffDownloadUrl = await uploadFile(bundleUploader, filePath, platform, identifier, {
+                type: 'asset-diff',
+                targetBinaryVersion: binaryVersion,
+                packageHash,
+                basePackageHash,
+            });
             diffPackages[basePackageHash] = diffDownloadUrl;
             console.log(`log: Asset diff archive against ${basePackageHash} uploaded (download url: ${diffDownloadUrl})`);
         } catch (error) {
@@ -289,6 +317,7 @@ async function makeAssetDiffArtifacts({
     bundleDownloader,
     bundleDirectory,
     packageHash,
+    targetBinaryVersion,
     platform,
     identifier,
 }: {
@@ -298,6 +327,7 @@ async function makeAssetDiffArtifacts({
     bundleDownloader: NonNullable<CliConfigInterface['bundleDownloader']>;
     bundleDirectory: string;
     packageHash: string;
+    targetBinaryVersion: string;
     platform: 'ios' | 'android';
     identifier: string | undefined;
 }): Promise<AssetDiffArtifact[]> {
@@ -307,6 +337,7 @@ async function makeAssetDiffArtifacts({
         bundleDownloader,
         platform,
         identifier,
+        targetBinaryVersion,
     });
 
     const artifacts: AssetDiffArtifact[] = [];
@@ -421,10 +452,11 @@ async function uploadArtifact(
     filePath: string,
     platform: 'ios' | 'android',
     identifier: string | undefined,
+    artifact: BundleUploadArtifact,
     artifactName: string,
 ): Promise<string> {
     try {
-        return await uploadFile(bundleUploader, filePath, platform, identifier);
+        return await uploadFile(bundleUploader, filePath, platform, identifier, artifact);
     } catch (error) {
         console.error(`Failed to upload the ${artifactName} file. Exiting the program.\n`, error)
         process.exit(1)
@@ -436,7 +468,8 @@ async function uploadFile(
     filePath: string,
     platform: 'ios' | 'android',
     identifier: string | undefined,
+    artifact: BundleUploadArtifact,
 ): Promise<string> {
-    const { downloadUrl } = await bundleUploader(filePath, platform, identifier);
+    const { downloadUrl } = await bundleUploader(filePath, platform, identifier, artifact);
     return downloadUrl
 }

package/cli/dist/commands/releaseCommand/release.js

@@ -51,16 +51,25 @@ export async function release(bundleUploader, getReleaseHistory, setReleaseHisto
             bundleDownloader,
             bundleDirectory,
             packageHash,
+            targetBinaryVersion: binaryVersion,
             platform,
             identifier,
         })
         : [];
     // Every artifact is uploaded before the release history is touched, so a failed
     // upload leaves the history describing only updates that can actually be downloaded.
-    const downloadUrl = await uploadArtifact(bundleUploader, bundleFilePath, platform, identifier, 'bundle');
+    const downloadUrl = await uploadArtifact(bundleUploader, bundleFilePath, platform, identifier, {
+        type: 'full-bundle',
+        targetBinaryVersion: binaryVersion,
+        packageHash,
+    }, 'bundle');
     let patchDownloadUrl;
     if (binaryPatch) {
-        patchDownloadUrl = await uploadArtifact(bundleUploader, binaryPatch.patchBundleFilePath, platform, identifier, 'binary patch bundle');
+        patchDownloadUrl = await uploadArtifact(bundleUploader, binaryPatch.patchBundleFilePath, platform, identifier, {
+            type: 'binary-patch',
+            targetBinaryVersion: binaryVersion,
+            packageHash,
+        }, 'binary patch bundle');
         console.log(`log: Binary patch archive uploaded (download url: ${patchDownloadUrl})`);
     }
     const diffPackages = {};
@@ -69,7 +78,12 @@ export async function release(bundleUploader, getReleaseHistory, setReleaseHisto
         // one that cannot be uploaded is left out of the history instead of failing the
         // release the other two artifacts are ready for.
         try {
-            const diffDownloadUrl = await uploadFile(bundleUploader, filePath, platform, identifier);
+            const diffDownloadUrl = await uploadFile(bundleUploader, filePath, platform, identifier, {
+                type: 'asset-diff',
+                targetBinaryVersion: binaryVersion,
+                packageHash,
+                basePackageHash,
+            });
             diffPackages[basePackageHash] = diffDownloadUrl;
             console.log(`log: Asset diff archive against ${basePackageHash} uploaded (download url: ${diffDownloadUrl})`);
         }
@@ -180,13 +194,14 @@ async function makeBinaryPatchArtifact({ baseBundlePath, contentsPath, bundleFil
  *
  * @return {Promise<AssetDiffArtifact[]>} The diff archives to upload, each naming the package it was built against.
  */
-async function makeAssetDiffArtifacts({ patchBundleFilePath, releaseHistory, diffBaseCount, bundleDownloader, bundleDirectory, packageHash, platform, identifier, }) {
+async function makeAssetDiffArtifacts({ patchBundleFilePath, releaseHistory, diffBaseCount, bundleDownloader, bundleDirectory, packageHash, targetBinaryVersion, platform, identifier, }) {
     const bases = await resolveAssetDiffBases({
         releaseHistory,
         diffBaseCount,
         bundleDownloader,
         platform,
         identifier,
+        targetBinaryVersion,
     });
     const artifacts = [];
     const builtAgainst = new Set();
@@ -278,16 +293,16 @@ function warnOnBaseBundleMismatch(outputPath, baseBundlePath) {
     }
 }
 /** Uploads an artifact the release cannot go out without, so a failure ends the program. */
-async function uploadArtifact(bundleUploader, filePath, platform, identifier, artifactName) {
+async function uploadArtifact(bundleUploader, filePath, platform, identifier, artifact, artifactName) {
     try {
-        return await uploadFile(bundleUploader, filePath, platform, identifier);
+        return await uploadFile(bundleUploader, filePath, platform, identifier, artifact);
     }
     catch (error) {
         console.error(`Failed to upload the ${artifactName} file. Exiting the program.\n`, error);
         process.exit(1);
     }
 }
-async function uploadFile(bundleUploader, filePath, platform, identifier) {
-    const { downloadUrl } = await bundleUploader(filePath, platform, identifier);
+async function uploadFile(bundleUploader, filePath, platform, identifier, artifact) {
+    const { downloadUrl } = await bundleUploader(filePath, platform, identifier, artifact);
     return downloadUrl;
 }

package/cli/dist/commands/releaseCommand/release.test.js

@@ -66,12 +66,12 @@ class ProcessExitError extends Error {
     }
 }
 function recordingUploader(uploads, failOn) {
-    return async (filePath) => {
+    return async (filePath, _platform, _identifier, artifact) => {
         if (failOn?.(filePath)) {
             throw new Error(`upload rejected: ${path.basename(filePath)}`);
         }
         const downloadUrl = `https://cdn.example.com/${path.basename(filePath)}`;
-        uploads.push({ filePath, downloadUrl, logCountBeforeUpload: logs.length });
+        uploads.push({ artifact, filePath, downloadUrl, logCountBeforeUpload: logs.length });
         return { downloadUrl };
     };
 }
@@ -124,11 +124,21 @@ afterEach(() => {
     fs.rmSync(path.resolve(process.cwd(), `${BINARY_VERSION}.json`), { force: true });
 });
 describe("release without --binary-bundle-path", () => {
+    it("keeps existing three-argument uploaders callable", async () => {
+        const legacyUploader = async (source, _platform, _identifier) => ({ downloadUrl: source });
+        const uploader = legacyUploader;
+        await expect(uploader('bundle.zip', 'ios')).resolves.toEqual({ downloadUrl: 'bundle.zip' });
+    });
     it("uploads the full bundle only, exactly as before binary patches existed", async () => {
         const staged = await stageBundleOutput("full-only");
         const { uploads, releaseHistories } = await runRelease(staged);
         expect(uploads).toHaveLength(1);
         expect(uploads[0].filePath).toBe(`${staged.bundleDirectory}/${staged.bundleFileName}`);
+        expect(uploads[0].artifact).toEqual({
+            type: 'full-bundle',
+            targetBinaryVersion: BINARY_VERSION,
+            packageHash: staged.bundleFileName,
+        });
         expect(fs.readdirSync(staged.bundleDirectory)).toEqual([staged.bundleFileName]);
         expect(releaseHistories[0][APP_VERSION]).toEqual({
             enabled: true,
@@ -426,11 +436,11 @@ describe("release with asset diff bases", () => {
     }
     /** Serves the staged base archives, and records which releases were asked for. */
     function recordingDownloader(bases, downloads) {
-        return async (downloadUrl) => {
-            downloads.push(downloadUrl);
-            const base = bases.find((candidate) => candidate.downloadUrl === downloadUrl);
+        return async (archive) => {
+            downloads.push(archive.downloadUrl);
+            const base = bases.find((candidate) => candidate.downloadUrl === archive.downloadUrl);
             if (!base) {
-                throw new Error(`the downloader was called with an unexpected url: ${downloadUrl}`);
+                throw new Error(`the downloader was called with an unexpected url: ${archive.downloadUrl}`);
             }
             return { downloadedFilePath: base.archivePath };
         };
@@ -452,6 +462,24 @@ describe("release with asset diff bases", () => {
             `${staged.bundleFileName}${BINARY_PATCH_ARCHIVE_SUFFIX}`,
             diffFileName,
         ]);
+        expect(uploads.map(({ artifact }) => artifact)).toEqual([
+            {
+                type: 'full-bundle',
+                targetBinaryVersion: BINARY_VERSION,
+                packageHash: staged.bundleFileName,
+            },
+            {
+                type: 'binary-patch',
+                targetBinaryVersion: BINARY_VERSION,
+                packageHash: staged.bundleFileName,
+            },
+            {
+                type: 'asset-diff',
+                targetBinaryVersion: BINARY_VERSION,
+                packageHash: staged.bundleFileName,
+                basePackageHash: base.packageHash,
+            },
+        ]);
         expect(downloads).toEqual([base.downloadUrl]);
         // Every artifact is uploaded before the history points at any of them.
         expect(uploadCountsWhenHistorySaved).toEqual([3]);

package/cli/dist/functions/resolveAssetDiffBases.js

@@ -25,7 +25,7 @@ const TEMP_DIR_PREFIX = 'codepush-asset-diff-base-';
  * @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, }) {
+export async function resolveAssetDiffBases({ releaseHistory, diffBaseCount, bundleDownloader, platform, identifier, targetBinaryVersion, }) {
     // 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
@@ -37,7 +37,12 @@ export async function resolveAssetDiffBases({ releaseHistory, diffBaseCount, bun
     const bases = [];
     for (const [version, releaseInfo] of candidates) {
         try {
-            const { downloadedFilePath } = await bundleDownloader(releaseInfo.downloadUrl, platform, identifier);
+            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}).`);

package/cli/dist/functions/resolveAssetDiffBases.test.js

@@ -13,6 +13,7 @@ import { resolveAssetDiffBases } from "./resolveAssetDiffBases.js";
 const CONTENTS_DIR_NAME = 'CodePush';
 /** Where the resolver unpacks a base for verification, so leftovers are recognizable. */
 const TEMP_DIR_PREFIX = 'codepush-asset-diff-base-';
+const TARGET_BINARY_VERSION = '1.0.0';
 let workDir;
 let bundleDirectory;
 /** Releases one full archive the way the CLI does, and returns what the history records. */
@@ -49,16 +50,16 @@ function releaseHistoryOf(releases) {
 /** Stands in for the consumer's downloader: hands back a local archive per download url. */
 function fakeDownloader(archives) {
     const calls = [];
-    const download = async (downloadUrl, platform, identifier) => {
-        calls.push([downloadUrl, platform, identifier]);
-        const archive = archives[downloadUrl];
-        if (archive instanceof Error) {
-            throw archive;
+    const download = async (downloadInfo, platform, identifier) => {
+        calls.push([downloadInfo, platform, identifier]);
+        const downloadedArchive = archives[downloadInfo.downloadUrl];
+        if (downloadedArchive instanceof Error) {
+            throw downloadedArchive;
         }
-        if (!archive) {
-            throw new Error(`the downloader was called with an unexpected url: ${downloadUrl}`);
+        if (!downloadedArchive) {
+            throw new Error(`the downloader was called with an unexpected url: ${downloadInfo.downloadUrl}`);
         }
-        return { downloadedFilePath: archive };
+        return { downloadedFilePath: downloadedArchive };
     };
     return { download, calls };
 }
@@ -86,14 +87,15 @@ describe("resolveAssetDiffBases", () => {
             bundleDownloader: download,
             platform: 'android',
             identifier: 'my-app',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
         expect(bases).toEqual([
             { basePackageHash: newest.packageHash, baseBundleFilePath: newest.archivePath },
             { basePackageHash: second.packageHash, baseBundleFilePath: second.archivePath },
         ]);
         expect(calls).toEqual([
-            [newest.downloadUrl, 'android', 'my-app'],
-            [second.downloadUrl, 'android', 'my-app'],
+            [{ downloadUrl: newest.downloadUrl, targetBinaryVersion: TARGET_BINARY_VERSION, releaseVersion: newest.version, packageHash: newest.packageHash }, 'android', 'my-app'],
+            [{ downloadUrl: second.downloadUrl, targetBinaryVersion: TARGET_BINARY_VERSION, releaseVersion: second.version, packageHash: second.packageHash }, 'android', 'my-app'],
         ]);
     });
     it("skips history entries that lack a download url or a package hash", async () => {
@@ -109,11 +111,16 @@ describe("resolveAssetDiffBases", () => {
             diffBaseCount: 1,
             bundleDownloader: download,
             platform: 'ios',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
         expect(bases).toEqual([
             { basePackageHash: released.packageHash, baseBundleFilePath: released.archivePath },
         ]);
-        expect(calls).toEqual([[released.downloadUrl, 'ios', undefined]]);
+        expect(calls).toEqual([[
+                { downloadUrl: released.downloadUrl, targetBinaryVersion: TARGET_BINARY_VERSION, releaseVersion: released.version, packageHash: released.packageHash },
+                'ios',
+                undefined,
+            ]]);
     });
     it("ignores a history entry whose key is not a version, and resolves the rest", async () => {
         const [released] = await stageReleases(['1.4.0']);
@@ -131,11 +138,16 @@ describe("resolveAssetDiffBases", () => {
             diffBaseCount: 2,
             bundleDownloader: download,
             platform: 'ios',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
         expect(bases).toEqual([
             { basePackageHash: released.packageHash, baseBundleFilePath: released.archivePath },
         ]);
-        expect(calls).toEqual([[released.downloadUrl, 'ios', undefined]]);
+        expect(calls).toEqual([[
+                { downloadUrl: released.downloadUrl, targetBinaryVersion: TARGET_BINARY_VERSION, releaseVersion: released.version, packageHash: released.packageHash },
+                'ios',
+                undefined,
+            ]]);
     });
     it("drops a base whose downloaded bytes do not match its recorded package hash", async () => {
         const [older, newer] = await stageReleases(['1.2.0', '1.2.1']);
@@ -150,6 +162,7 @@ describe("resolveAssetDiffBases", () => {
             diffBaseCount: 2,
             bundleDownloader: download,
             platform: 'android',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
         expect(bases).toEqual([{ basePackageHash: older.packageHash, baseBundleFilePath: older.archivePath }]);
         expect(warn.mock.calls.join('\n')).toMatch(/1\.2\.1/);
@@ -167,6 +180,7 @@ describe("resolveAssetDiffBases", () => {
             diffBaseCount: 2,
             bundleDownloader: download,
             platform: 'android',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
         expect(bases).toEqual([{ basePackageHash: older.packageHash, baseBundleFilePath: older.archivePath }]);
         expect(warn.mock.calls.join('\n')).toMatch(/1\.3\.1.*the network is down/s);

package/cli/functions/resolveAssetDiffBases.test.ts

@@ -4,7 +4,7 @@ import path from "path";
 import { afterAll, afterEach, beforeAll, describe, expect, it, jest } from "@jest/globals";
 import { makeCodePushBundle } from "./makeCodePushBundle.js";
 import { resolveAssetDiffBases } from "./resolveAssetDiffBases.js";
-import type { CliConfigInterface, ReleaseHistoryInterface } from "../../typings/react-native-code-push.d.ts";
+import type { BundleDownloadInfo, CliConfigInterface, ReleaseHistoryInterface } from "../../typings/react-native-code-push.d.ts";
 
 /**
  * Exercises base acquisition against real archives and real hashes: a base is only usable
@@ -17,6 +17,7 @@ const CONTENTS_DIR_NAME = 'CodePush';
 
 /** Where the resolver unpacks a base for verification, so leftovers are recognizable. */
 const TEMP_DIR_PREFIX = 'codepush-asset-diff-base-';
+const TARGET_BINARY_VERSION = '1.0.0';
 
 type StagedRelease = {
     version: string;
@@ -68,22 +69,22 @@ function releaseHistoryOf(releases: StagedRelease[]): ReleaseHistoryInterface {
 
 /** Stands in for the consumer's downloader: hands back a local archive per download url. */
 function fakeDownloader(archives: Record<string, string | Error>) {
-    const calls: Array<[string, string, string | undefined]> = [];
+    const calls: Array<[BundleDownloadInfo, string, string | undefined]> = [];
     const download: NonNullable<CliConfigInterface['bundleDownloader']> = async (
-        downloadUrl,
+        downloadInfo,
         platform,
         identifier,
     ) => {
-        calls.push([downloadUrl, platform, identifier]);
+        calls.push([downloadInfo, platform, identifier]);
 
-        const archive = archives[downloadUrl];
-        if (archive instanceof Error) {
-            throw archive;
+        const downloadedArchive = archives[downloadInfo.downloadUrl];
+        if (downloadedArchive instanceof Error) {
+            throw downloadedArchive;
         }
-        if (!archive) {
-            throw new Error(`the downloader was called with an unexpected url: ${downloadUrl}`);
+        if (!downloadedArchive) {
+            throw new Error(`the downloader was called with an unexpected url: ${downloadInfo.downloadUrl}`);
         }
-        return { downloadedFilePath: archive };
+        return { downloadedFilePath: downloadedArchive };
     };
     return { download, calls };
 }
@@ -119,6 +120,7 @@ describe("resolveAssetDiffBases", () => {
             bundleDownloader: download,
             platform: 'android',
             identifier: 'my-app',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
 
         expect(bases).toEqual([
@@ -126,8 +128,8 @@ describe("resolveAssetDiffBases", () => {
             { basePackageHash: second.packageHash, baseBundleFilePath: second.archivePath },
         ]);
         expect(calls).toEqual([
-            [newest.downloadUrl, 'android', 'my-app'],
-            [second.downloadUrl, 'android', 'my-app'],
+            [{ downloadUrl: newest.downloadUrl, targetBinaryVersion: TARGET_BINARY_VERSION, releaseVersion: newest.version, packageHash: newest.packageHash }, 'android', 'my-app'],
+            [{ downloadUrl: second.downloadUrl, targetBinaryVersion: TARGET_BINARY_VERSION, releaseVersion: second.version, packageHash: second.packageHash }, 'android', 'my-app'],
         ]);
     });
 
@@ -145,12 +147,17 @@ describe("resolveAssetDiffBases", () => {
             diffBaseCount: 1,
             bundleDownloader: download,
             platform: 'ios',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
 
         expect(bases).toEqual([
             { basePackageHash: released.packageHash, baseBundleFilePath: released.archivePath },
         ]);
-        expect(calls).toEqual([[released.downloadUrl, 'ios', undefined]]);
+        expect(calls).toEqual([[
+            { downloadUrl: released.downloadUrl, targetBinaryVersion: TARGET_BINARY_VERSION, releaseVersion: released.version, packageHash: released.packageHash },
+            'ios',
+            undefined,
+        ]]);
     });
 
     it("ignores a history entry whose key is not a version, and resolves the rest", async () => {
@@ -170,12 +177,17 @@ describe("resolveAssetDiffBases", () => {
             diffBaseCount: 2,
             bundleDownloader: download,
             platform: 'ios',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
 
         expect(bases).toEqual([
             { basePackageHash: released.packageHash, baseBundleFilePath: released.archivePath },
         ]);
-        expect(calls).toEqual([[released.downloadUrl, 'ios', undefined]]);
+        expect(calls).toEqual([[
+            { downloadUrl: released.downloadUrl, targetBinaryVersion: TARGET_BINARY_VERSION, releaseVersion: released.version, packageHash: released.packageHash },
+            'ios',
+            undefined,
+        ]]);
     });
 
     it("drops a base whose downloaded bytes do not match its recorded package hash", async () => {
@@ -192,6 +204,7 @@ describe("resolveAssetDiffBases", () => {
             diffBaseCount: 2,
             bundleDownloader: download,
             platform: 'android',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
 
         expect(bases).toEqual([{ basePackageHash: older.packageHash, baseBundleFilePath: older.archivePath }]);
@@ -212,6 +225,7 @@ describe("resolveAssetDiffBases", () => {
             diffBaseCount: 2,
             bundleDownloader: download,
             platform: 'android',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
 
         expect(bases).toEqual([{ basePackageHash: older.packageHash, baseBundleFilePath: older.archivePath }]);

package/cli/functions/resolveAssetDiffBases.ts

@@ -40,12 +40,14 @@ export async function resolveAssetDiffBases({
     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
@@ -60,7 +62,12 @@ export async function resolveAssetDiffBases({
     const bases: AssetDiffBase[] = [];
     for (const [version, releaseInfo] of candidates) {
         try {
-            const { downloadedFilePath } = await bundleDownloader(releaseInfo.downloadUrl, platform, identifier);
+            const { downloadedFilePath } = await bundleDownloader({
+                downloadUrl: releaseInfo.downloadUrl,
+                targetBinaryVersion,
+                releaseVersion: version,
+                packageHash: releaseInfo.packageHash,
+            }, platform, identifier);
 
             if (!(await matchesPackageHash(downloadedFilePath, releaseInfo.packageHash))) {
                 console.warn(

package/package.json

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

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

@@ -633,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.
  *
@@ -647,26 +672,16 @@ 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}>;
 
-    /**
-     * 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.
-     */
-    bundleDownloader?: (
-        downloadUrl: string,
-        platform: "ios" | "android",
-        identifier?: string,
-    ) => Promise<{ downloadedFilePath: string }>;
-
     /**
      * Interface that must be implemented to retrieve ReleaseHistory information.
      *
@@ -702,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 }>;
 }