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

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 };
     };
 }
@@ -198,12 +206,23 @@ beforeEach(() => {
 
 afterEach(() => {
     jest.restoreAllMocks();
-    // addToReleaseHistory writes its JSON next to the invocation, and only removes it
-    // when the history was stored successfully.
-    fs.rmSync(path.resolve(process.cwd(), `${BINARY_VERSION}.json`), { force: true });
+    // addToReleaseHistory writes its JSON under the directory it was invoked in, and only
+    // removes it when the history was stored successfully.
+    fs.rmSync(path.resolve(process.cwd(), "codepush-release-history"), { recursive: true, force: true });
 });
 
 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/commands/updateHistoryCommand/updateReleaseHistory.ts

@@ -1,6 +1,5 @@
-import fs from "fs";
-import path from "path";
 import type { CliConfigInterface } from "../../../typings/react-native-code-push.d.ts";
+import { stageReleaseHistoryFile } from "../../functions/stageReleaseHistoryFile.js";
 
 export async function updateReleaseHistory(
     appVersion: string,
@@ -23,15 +22,8 @@ export async function updateReleaseHistory(
     if (typeof rollout === "number") updateInfo.rollout = rollout;
 
     try {
-        const JSON_FILE_NAME = `${binaryVersion}.json`;
-        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
-
-        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(releaseHistory, null, 2));
-        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(releaseHistory));
-
-        await setReleaseHistory(binaryVersion, JSON_FILE_PATH, releaseHistory, platform, identifier)
-
-        fs.unlinkSync(JSON_FILE_PATH);
+        await stageReleaseHistoryFile(binaryVersion, releaseHistory, platform, (jsonFilePath) =>
+            setReleaseHistory(binaryVersion, jsonFilePath, releaseHistory, platform, identifier));
     } catch (error) {
         console.error('Error occurred while updating history:', error);
         process.exit(1)

package/cli/dist/commands/createHistoryCommand/createReleaseHistory.js

@@ -1,5 +1,4 @@
-import fs from "fs";
-import path from "path";
+import { stageReleaseHistoryFile } from "../../functions/stageReleaseHistoryFile.js";
 export async function createReleaseHistory(targetVersion, setReleaseHistory, platform, identifier) {
     const BINARY_RELEASE = {
         enabled: true,
@@ -11,12 +10,7 @@ export async function createReleaseHistory(targetVersion, setReleaseHistory, pla
         [targetVersion]: BINARY_RELEASE
     };
     try {
-        const JSON_FILE_NAME = `${targetVersion}.json`;
-        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
-        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(INITIAL_HISTORY, null, 2));
-        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(INITIAL_HISTORY));
-        await setReleaseHistory(targetVersion, JSON_FILE_PATH, INITIAL_HISTORY, platform, identifier);
-        fs.unlinkSync(JSON_FILE_PATH);
+        await stageReleaseHistoryFile(targetVersion, INITIAL_HISTORY, platform, (jsonFilePath) => setReleaseHistory(targetVersion, jsonFilePath, INITIAL_HISTORY, platform, identifier));
     }
     catch (error) {
         console.error('Error occurred while creating new history:', error);

package/cli/dist/commands/createHistoryCommand/createReleaseHistory.test.js

@@ -0,0 +1,95 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, beforeEach, describe, expect, it, jest } from "@jest/globals";
+import { createReleaseHistory } from "./createReleaseHistory.js";
+import { updateReleaseHistory } from "../updateHistoryCommand/updateReleaseHistory.js";
+/**
+ * Covers where the release history is staged before the config is handed it.
+ *
+ * The config receives a path rather than the history itself, so the command has to put the
+ * file somewhere first. Two releases of one app for different platforms are the same binary
+ * version, so a staging path derived from that version alone is the same path for both, and
+ * they overwrite each other's contents before either has read its own.
+ */
+const BINARY_VERSION = "1.0.0";
+let workingDir;
+let previousCwd;
+beforeEach(() => {
+    previousCwd = process.cwd();
+    workingDir = fs.mkdtempSync(path.join(os.tmpdir(), "codepush-history-staging-"));
+    process.chdir(workingDir);
+});
+afterEach(() => {
+    process.chdir(previousCwd);
+    fs.rmSync(workingDir, { recursive: true, force: true });
+    jest.restoreAllMocks();
+});
+function stagedPath(platform) {
+    return path.join(workingDir, "codepush-release-history", platform, `${BINARY_VERSION}.json`);
+}
+/**
+ * Turns the command's own exit into a throw, so a staging failure fails the test instead
+ * of taking the worker down with it.
+ */
+function failOnExit() {
+    jest.spyOn(process, "exit").mockImplementation((code) => {
+        throw new Error(`the command exited with code ${String(code)}`);
+    });
+    jest.spyOn(console, "error").mockImplementation(() => undefined);
+    jest.spyOn(console, "log").mockImplementation(() => undefined);
+}
+describe("staging the release history a config is handed", () => {
+    it("gives each platform writing at the same time a file of its own", async () => {
+        failOnExit();
+        const staged = {};
+        const setReleaseHistory = async (_binaryVersion, jsonFilePath, _releaseInfo, platform) => {
+            // Yields once, which is all it takes for the other platform to reach its own
+            // write and its own clean-up while this one still holds only a path.
+            await Promise.resolve();
+            staged[platform] = { jsonFilePath, contents: fs.readFileSync(jsonFilePath, "utf8") };
+        };
+        await Promise.all([
+            createReleaseHistory(BINARY_VERSION, setReleaseHistory, "ios", "RN0840"),
+            createReleaseHistory(BINARY_VERSION, setReleaseHistory, "android", "RN0840"),
+        ]);
+        expect(staged.ios.jsonFilePath).not.toBe(staged.android.jsonFilePath);
+    });
+    it("hands each platform the history that platform released", async () => {
+        failOnExit();
+        const released = {
+            ios: JSON.stringify({ [BINARY_VERSION]: { enabled: true, mandatory: false, downloadUrl: "", packageHash: "" }, "1.0.1": { enabled: true, mandatory: true, downloadUrl: "ios-url", packageHash: "ios-hash" } }),
+            android: JSON.stringify({ [BINARY_VERSION]: { enabled: true, mandatory: false, downloadUrl: "", packageHash: "" }, "1.0.1": { enabled: true, mandatory: true, downloadUrl: "android-url", packageHash: "android-hash" } }),
+        };
+        const staged = {};
+        const getReleaseHistory = async (_binaryVersion, platform) => JSON.parse(released[platform]);
+        const setReleaseHistory = async (_binaryVersion, jsonFilePath, _releaseInfo, platform) => {
+            await Promise.resolve();
+            staged[platform] = fs.readFileSync(jsonFilePath, "utf8");
+        };
+        await Promise.all([
+            updateReleaseHistory("1.0.1", BINARY_VERSION, getReleaseHistory, setReleaseHistory, "ios", "RN0840", undefined, false, undefined),
+            updateReleaseHistory("1.0.1", BINARY_VERSION, getReleaseHistory, setReleaseHistory, "android", "RN0840", undefined, false, undefined),
+        ]);
+        expect(staged.ios).toContain("ios-url");
+        expect(staged.ios).not.toContain("android-url");
+        expect(staged.android).toContain("android-url");
+        expect(staged.android).not.toContain("ios-url");
+    });
+    it("takes the file away once the config has stored the history", async () => {
+        failOnExit();
+        const setReleaseHistory = async () => undefined;
+        await createReleaseHistory(BINARY_VERSION, setReleaseHistory, "ios", "RN0840");
+        expect(fs.existsSync(stagedPath("ios"))).toBe(false);
+    });
+    it("leaves the file behind when the config could not store the history", async () => {
+        failOnExit();
+        const setReleaseHistory = async () => {
+            throw new Error("the storage backend rejected the history");
+        };
+        await expect(createReleaseHistory(BINARY_VERSION, setReleaseHistory, "ios", "RN0840")).rejects.toThrow("the command exited with code 1");
+        // What the release tried to store is worth reading back, so a failed release keeps
+        // its history at a path that is the same on every run.
+        expect(Object.keys(JSON.parse(fs.readFileSync(stagedPath("ios"), "utf8")))).toEqual([BINARY_VERSION]);
+    });
+});

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

@@ -1,5 +1,4 @@
-import path from "path";
-import fs from "fs";
+import { stageReleaseHistoryFile } from "../../functions/stageReleaseHistoryFile.js";
 export async function addToReleaseHistory(appVersion, binaryVersion, bundleDownloadUrl, binaryPatchDownloadUrl, packageHash, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout, diffPackages) {
     const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
     const updateInfo = releaseHistory[appVersion];
@@ -28,12 +27,7 @@ export async function addToReleaseHistory(appVersion, binaryVersion, bundleDownl
         newReleaseHistory[appVersion].rollout = rollout;
     }
     try {
-        const JSON_FILE_NAME = `${binaryVersion}.json`;
-        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
-        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(newReleaseHistory, null, 2));
-        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(newReleaseHistory));
-        await setReleaseHistory(binaryVersion, JSON_FILE_PATH, newReleaseHistory, platform, identifier);
-        fs.unlinkSync(JSON_FILE_PATH);
+        await stageReleaseHistoryFile(binaryVersion, newReleaseHistory, platform, (jsonFilePath) => setReleaseHistory(binaryVersion, jsonFilePath, newReleaseHistory, platform, identifier));
     }
     catch (error) {
         console.error('Error occurred while updating history:', error);

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 };
     };
 }
@@ -119,16 +119,26 @@ beforeEach(() => {
 });
 afterEach(() => {
     jest.restoreAllMocks();
-    // addToReleaseHistory writes its JSON next to the invocation, and only removes it
-    // when the history was stored successfully.
-    fs.rmSync(path.resolve(process.cwd(), `${BINARY_VERSION}.json`), { force: true });
+    // addToReleaseHistory writes its JSON under the directory it was invoked in, and only
+    // removes it when the history was stored successfully.
+    fs.rmSync(path.resolve(process.cwd(), "codepush-release-history"), { recursive: true, 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/commands/updateHistoryCommand/updateReleaseHistory.js

@@ -1,5 +1,4 @@
-import fs from "fs";
-import path from "path";
+import { stageReleaseHistoryFile } from "../../functions/stageReleaseHistoryFile.js";
 export async function updateReleaseHistory(appVersion, binaryVersion, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout) {
     const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
     const updateInfo = releaseHistory[appVersion];
@@ -12,12 +11,7 @@ export async function updateReleaseHistory(appVersion, binaryVersion, getRelease
     if (typeof rollout === "number")
         updateInfo.rollout = rollout;
     try {
-        const JSON_FILE_NAME = `${binaryVersion}.json`;
-        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
-        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(releaseHistory, null, 2));
-        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(releaseHistory));
-        await setReleaseHistory(binaryVersion, JSON_FILE_PATH, releaseHistory, platform, identifier);
-        fs.unlinkSync(JSON_FILE_PATH);
+        await stageReleaseHistoryFile(binaryVersion, releaseHistory, platform, (jsonFilePath) => setReleaseHistory(binaryVersion, jsonFilePath, releaseHistory, platform, identifier));
     }
     catch (error) {
         console.error('Error occurred while updating history:', error);

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}).`);