@bravemobile/react-native-code-push 13.1.0-beta.6 → 13.2.0

package/README.md

@@ -394,7 +394,18 @@ module.exports = Config;
   - Modifying an existing release history with the `update-history` command.
 
 
-**(2) For `code-push.config.ts` (TypeScript) to work properly, you may need to update your `tsconfig.json`.**
+**(2) A `code-push.config.ts` (TypeScript) file needs a loader installed.**
+
+Install `tsx`, which requires no further setup:
+
+```bash
+npm install --save-dev tsx
+```
+
+`ts-node` also keeps working, and is used when `tsx` is not installed. Note that `ts-node` is no
+longer maintained, so support for it is **deprecated and will be removed in a future major
+version** — please migrate to `tsx`. Until then, `ts-node` needs the following `tsconfig.json`
+setup:
 
 ```diff
   {
@@ -414,6 +425,8 @@ module.exports = Config;
 
 ```
 
+A `code-push.config.js` (JavaScript) file needs neither.
+
 
 ### 6. Diff Updates (Optional)
 

package/android/app/proguard-rules.pro

@@ -21,10 +21,6 @@
     private final ** mBundleLoader;
 }
 # bridgeless
--keepclassmembers class com.facebook.react.defaults.DefaultReactHostDelegate {
-    private ** jsBundleLoader;
-}
-# bridgeless
 -keepclassmembers class * extends com.facebook.react.runtime.ReactHostDelegate {
     private ** jsBundleLoader;
     private ** _jsBundleLoader;
@@ -35,9 +31,6 @@
     private final ** reactHostDelegate; # RN 0.81+
 }
 
-# Can't find referenced class org.bouncycastle.**
--dontwarn com.nimbusds.jose.**
-
 # The binary patch applier is found by name from the native library.
 -keepclasseswithmembernames class com.microsoft.codepush.react.HDiffPatchNative {
     native <methods>;

package/android/app/src/main/java/com/microsoft/codepush/react/CodePush.java

@@ -51,6 +51,9 @@ public class CodePush extends TurboReactPackage {
         return mServerUrl;
     }
 
+    /**
+     * Entry point used by React Native autolinking to create and retain the package instance.
+     */
     public static synchronized CodePush getInstance(Context context, boolean isDebugMode) {
         if (mCurrentInstance == null) {
             mCurrentInstance = new CodePush(context, isDebugMode);

package/android/app/src/main/java/com/microsoft/codepush/react/CodePushNativeModule.java

@@ -59,6 +59,15 @@ public class CodePushNativeModule extends NativeCodePushSpec {
     private  boolean _restartInProgress = false;
     private  ArrayList<Boolean> _restartQueue = new ArrayList<>();
 
+    /**
+     * Whether the React Native instance this module was created for is still the one running.
+     *
+     * A reload replaces the instance while work this module started can still be in flight,
+     * and a frame callback posted to the process-wide choreographer outlives the executor
+     * this module shuts down. Read from whichever thread that work is on, so it is volatile.
+     */
+    private volatile boolean mGenerationAlive = true;
+
     public CodePushNativeModule(ReactApplicationContext reactContext, CodePush codePush, CodePushUpdateManager codePushUpdateManager, CodePushTelemetryManager codePushTelemetryManager, SettingsManager settingsManager) {
         super(reactContext);
 
@@ -85,6 +94,7 @@ public class CodePushNativeModule extends NativeCodePushSpec {
 
     @Override
     public void invalidate() {
+        mGenerationAlive = false;
         clearLifecycleEventListener();
         mBackgroundExecutor.shutdownNow();
         super.invalidate();
@@ -264,6 +274,14 @@ public class CodePushNativeModule extends NativeCodePushSpec {
     }
 
     private void emitDownloadProgressEvent(DownloadProgress downloadProgress) {
+        // Every progress event arrives here, including the ones a frame callback delivers
+        // after this module was invalidated: shutting the executor down does not cancel a
+        // callback already posted to the choreographer, and the context it would emit
+        // through has been destroyed by then.
+        if (!mGenerationAlive) {
+            return;
+        }
+
         if (mEventEmitterCallback != null) {
             emitOnDownloadProgress(downloadProgress.createWritableMap());
             return;
@@ -275,6 +293,13 @@ public class CodePushNativeModule extends NativeCodePushSpec {
     }
 
     private void restartAppInternal(boolean onlyIfUpdateIsPending) {
+        // A restart requested by an instance that has been replaced would reload the one
+        // that replaced it, which nobody asked for.
+        if (!mGenerationAlive) {
+            CodePushUtils.log("Ignoring a restart requested by a React Native instance that is no longer running");
+            return;
+        }
+
         if (this._restartInProgress) {
             CodePushUtils.log("Restart request queued until the current restart is completed");
             this._restartQueue.add(onlyIfUpdateIsPending);

package/cli/dist/utils/fsUtils.js

@@ -1,20 +1,15 @@
 import fs from "fs";
 import path from "path";
 import { createRequire } from "module";
-const nodeRequire = createRequire(import.meta.url);
 /**
  * allows to require a config file with .ts extension
  */
 function requireConfig(filePath) {
     const ext = path.extname(filePath);
+    // Resolve the loader from the project the config file lives in, not from the CLI install.
+    const projectRequire = createRequire(filePath);
     if (ext === '.ts') {
-        try {
-            nodeRequire('ts-node/register');
-        }
-        catch {
-            console.error('ts-node not found. Please install ts-node as a devDependency.');
-            process.exit(1);
-        }
+        return unwrapDefaultExport(requireTsConfig(projectRequire, filePath));
     }
     else if (ext === '.js') {
         // do nothing
@@ -22,7 +17,38 @@ function requireConfig(filePath) {
     else {
         throw new Error(`Unsupported file extension: ${ext}`);
     }
-    return nodeRequire(filePath);
+    return unwrapDefaultExport(projectRequire(filePath));
+}
+/**
+ * tsx is preferred: it needs no tsconfig setup and resolves tsconfig `paths` aliases on its own.
+ * ts-node keeps working for projects that already have it configured.
+ */
+function requireTsConfig(projectRequire, filePath) {
+    if (canResolve(projectRequire, 'tsx/cjs/api')) {
+        const { require: tsxRequire } = projectRequire('tsx/cjs/api');
+        return tsxRequire(filePath, filePath);
+    }
+    if (canResolve(projectRequire, 'ts-node/register')) {
+        console.warn('warn: Loading the config file with ts-node, which is no longer maintained. Support for it ' +
+            'will be removed in a future major version - please install tsx instead (`npm i -D tsx`).');
+        projectRequire('ts-node/register');
+        return projectRequire(filePath);
+    }
+    console.error('A TypeScript config file needs a loader. Please install tsx as a devDependency (`npm i -D tsx`).');
+    process.exit(1);
+}
+function canResolve(projectRequire, id) {
+    try {
+        projectRequire.resolve(id);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// `export default` compiles to `exports.default`; `module.exports =` is returned as is.
+function unwrapDefaultExport(loaded) {
+    return (loaded.default ?? loaded);
 }
 export function findAndReadConfigFile(startDir, configFileName) {
     let dir = startDir;

package/cli/package.json

@@ -19,11 +19,15 @@
     "yauzl": "^3.2.0"
   },
   "peerDependencies": {
-    "ts-node": ">=10"
+    "ts-node": ">=10",
+    "tsx": ">=4"
   },
   "peerDependenciesMeta": {
     "ts-node": {
       "optional": true
+    },
+    "tsx": {
+      "optional": true
     }
   },
   "engines": {

package/cli/utils/fsUtils.ts

@@ -3,28 +3,62 @@ import path from "path";
 import { createRequire } from "module";
 import type { CliConfigInterface } from "../../typings/react-native-code-push.d.ts";
 
-const nodeRequire = createRequire(import.meta.url);
-
 /**
  * allows to require a config file with .ts extension
  */
 function requireConfig(filePath: string): CliConfigInterface {
   const ext = path.extname(filePath);
+  // Resolve the loader from the project the config file lives in, not from the CLI install.
+  const projectRequire = createRequire(filePath);
 
   if (ext === '.ts') {
-    try {
-      nodeRequire('ts-node/register');
-    } catch {
-      console.error('ts-node not found. Please install ts-node as a devDependency.');
-      process.exit(1);
-    }
+    return unwrapDefaultExport(requireTsConfig(projectRequire, filePath));
   } else if (ext === '.js') {
     // do nothing
   } else {
     throw new Error(`Unsupported file extension: ${ext}`);
   }
 
-  return nodeRequire(filePath) as CliConfigInterface;
+  return unwrapDefaultExport(projectRequire(filePath));
+}
+
+/**
+ * tsx is preferred: it needs no tsconfig setup and resolves tsconfig `paths` aliases on its own.
+ * ts-node keeps working for projects that already have it configured.
+ */
+function requireTsConfig(projectRequire: NodeRequire, filePath: string): { default?: unknown } {
+  if (canResolve(projectRequire, 'tsx/cjs/api')) {
+    const { require: tsxRequire } = projectRequire('tsx/cjs/api') as {
+      require: (id: string, fromFile: string) => { default?: unknown };
+    };
+    return tsxRequire(filePath, filePath);
+  }
+
+  if (canResolve(projectRequire, 'ts-node/register')) {
+    console.warn(
+      'warn: Loading the config file with ts-node, which is no longer maintained. Support for it ' +
+        'will be removed in a future major version - please install tsx instead (`npm i -D tsx`).',
+    );
+    projectRequire('ts-node/register');
+    return projectRequire(filePath);
+  }
+
+  console.error('A TypeScript config file needs a loader. Please install tsx as a devDependency (`npm i -D tsx`).');
+  process.exit(1);
+}
+
+function canResolve(projectRequire: NodeRequire, id: string): boolean {
+  try {
+    projectRequire.resolve(id);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// `export default` compiles to `exports.default`; `module.exports =` is returned as is.
+function unwrapDefaultExport(loaded: { default?: unknown }): CliConfigInterface {
+  return (loaded.default ?? loaded) as CliConfigInterface;
 }
 
 export function findAndReadConfigFile(startDir: string, configFileName: string): CliConfigInterface {

package/ios/CodePush/CodePush.h

@@ -36,6 +36,10 @@
 @interface CodePush : RCTEventEmitter
 #endif
 
+/*
+ * Returns the bundle embedded in the binary, without resolving an installed update.
+ * The update pipeline uses this as the base for binary patches and asset diffs.
+ */
 + (NSURL *)binaryBundleURL;
 /*
  * This method is used to retrieve the URL for the most recent
@@ -64,8 +68,10 @@
                    subdirectory:(NSString *)resourceSubdirectory
                          bundle:(NSBundle *)resourceBundle;
 
+/* Internal storage root used by CodePushPackage. */
 + (NSString *)getApplicationSupportDirectory;
 
+/* Returns the embedded assets path used as the base for asset diffs. */
 + (NSString *)bundleAssetsPath;
 
 /*
@@ -76,9 +82,8 @@
 + (void)overrideAppVersion:(NSString *)appVersion;
 
 /*
- * This method allows dynamically setting the app's
- * deployment key, in addition to setting it via
- * the Info.plist file's CodePushDeploymentKey setting.
+ * Retained for compatibility. The current implementation ignores the argument
+ * and uses the deprecated deployment key placeholder.
  */
 + (void)setDeploymentKey:(NSString *)deploymentKey;
 

package/ios/CodePush/CodePush.mm

@@ -1,6 +1,7 @@
 #import <React/RCTAssert.h>
 #import <React/RCTBridgeModule.h>
 #import <React/RCTConvert.h>
+#import <React/RCTInvalidating.h>
 #import <React/RCTEventDispatcher.h>
 #import <React/RCTRootView.h>
 #import <React/RCTUtils.h>
@@ -8,7 +9,9 @@
 
 #import "CodePush.h"
 
-@interface CodePush () <RCTFrameUpdateObserver
+#include <atomic>
+
+@interface CodePush () <RCTFrameUpdateObserver, RCTInvalidating
 #ifdef RCT_NEW_ARCH_ENABLED
 , NativeCodePushSpec
 #endif
@@ -32,6 +35,17 @@
     BOOL _allowed;
     BOOL _restartInProgress;
     NSMutableArray *_restartQueue;
+
+    /*
+     * Whether the React Native instance this module was created for is still the one
+     * running.
+     *
+     * A reload starts the next instance before the one being replaced has finished being
+     * torn down, so work this instance started can still be running with nothing left to
+     * hand its result to. Read from whichever thread that work is on, written when the
+     * instance is invalidated, so it is atomic.
+     */
+    std::atomic<bool> _generationAlive;
 }
 
 RCT_EXPORT_MODULE()
@@ -307,7 +321,42 @@ static NSString *const LatestRollbackCountKey = @"count";
     [[NSNotificationCenter defaultCenter] removeObserver:self];
 }
 
+/*
+ * Called when the React Native instance this module belongs to is being replaced.
+ *
+ * A download in flight keeps this module alive past that point, and the suspend timer and
+ * the resume notifications keep it reachable too. None of them may act afterwards: the
+ * runtime they would report to is gone, and the restart they would trigger belongs to a
+ * generation that is no longer on screen.
+ */
+- (void)invalidate
+{
+    _generationAlive.store(false);
+
+    [_appSuspendTimer invalidate];
+    _appSuspendTimer = nil;
+    _hasResumeListener = NO;
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+
+#ifndef RCT_NEW_ARCH_ENABLED
+    [super invalidate];
+#endif
+}
+
+/* Whether this module still belongs to the React Native instance that is running. */
+- (BOOL)isGenerationAlive
+{
+    return _generationAlive.load();
+}
+
 - (void)dispatchDownloadProgressEvent {
+  // The download that is reporting here can be one this module started before the app was
+  // reloaded, in which case the event emitter it would reach belongs to a runtime that has
+  // been torn down.
+  if (![self isGenerationAlive]) {
+    return;
+  }
+
   // Notify the script-side about the progress
   NSDictionary *progress = @{
     @"totalBytes" : [NSNumber numberWithLongLong:_latestExpectedContentLength],
@@ -375,6 +424,7 @@ static NSString *const LatestRollbackCountKey = @"count";
     _restartInProgress = NO;
     _restartQueue = [NSMutableArray arrayWithCapacity:1];
     _lastProgressEventTime = 0;
+    _generationAlive.store(true);
 
     self = [super init];
     if (self) {
@@ -533,6 +583,11 @@ static NSString *const LatestRollbackCountKey = @"count";
  */
 - (void)loadBundle
 {
+    if (![self isGenerationAlive]) {
+        CPLog(@"Ignoring a reload requested by a React Native instance that is no longer running.");
+        return;
+    }
+
     @synchronized([CodePush class]) {
         hasInitializedUpdateAfterRestartForCurrentLoad = NO;
     }
@@ -802,6 +857,11 @@ RCT_EXPORT_METHOD(downloadUpdate:(NSDictionary*)updatePackage
 
 - (void)restartAppInternal:(BOOL)onlyIfUpdateIsPending
 {
+    if (![self isGenerationAlive]) {
+        CPLog(@"Ignoring a restart requested by a React Native instance that is no longer running.");
+        return;
+    }
+
     if (_restartInProgress) {
         CPLog(@"Restart request queued until the current restart is completed.");
         [_restartQueue addObject:@(onlyIfUpdateIsPending)];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bravemobile/react-native-code-push",
-  "version": "13.1.0-beta.6",
+  "version": "13.2.0",
   "description": "React Native plugin for the CodePush service",
   "main": "src/CodePush.js",
   "react-native": "src/CodePush.js",
@@ -71,8 +71,8 @@
   ],
   "scripts": {
     "setup": "npm install --quiet --no-progress",
-    "setup-example-app": "ts-node --project scripts/setupExampleApp/tsconfig.json scripts/setupExampleApp/runSetupExampleApp.ts",
-    "setup-expo-example-app": "ts-node --project scripts/setupExampleApp/tsconfig.json scripts/setupExpoExampleApp/runSetupExpoExampleApp.ts",
+    "setup-example-app": "tsx scripts/setupExampleApp/runSetupExampleApp.ts",
+    "setup-expo-example-app": "tsx scripts/setupExpoExampleApp/runSetupExpoExampleApp.ts",
     "type:src": "tsc --project tsconfig.json --noEmit",
     "type:cli": "npm run --workspace cli typecheck",
     "type:scripts": "tsc --project scripts/tsconfig.json --noEmit",
@@ -82,7 +82,7 @@
     "prepack": "npm run build:cli",
     "eslint": "eslint --quiet .",
     "jest": "jest src/CodePush.test.js src/versioning/* expo/* && npm run --workspace cli test",
-    "e2e": "ts-node --project e2e/tsconfig.json e2e/run.ts"
+    "e2e": "tsx e2e/run.ts"
   },
   "publishConfig": {
     "access": "public"
@@ -102,11 +102,19 @@
   },
   "peerDependencies": {
     "expo": ">=50.0.0",
-    "react-native": "*"
+    "react-native": "*",
+    "ts-node": ">=10",
+    "tsx": ">=4"
   },
   "peerDependenciesMeta": {
     "expo": {
       "optional": true
+    },
+    "ts-node": {
+      "optional": true
+    },
+    "tsx": {
+      "optional": true
     }
   },
   "devDependencies": {
@@ -128,7 +136,7 @@
     "jest": "^29.7.0",
     "react": "19.2.3",
     "react-native": "0.84.1",
-    "ts-node": "^10.9.2",
+    "tsx": "^4.23.13",
     "typescript": "5.0.4",
     "typescript-eslint": "^8.11.0"
   },

package/src/CodePush.js

@@ -2,6 +2,7 @@ import { Alert, AppState, Platform } from "react-native";
 import log from "./logging";
 import hoistStatics from 'hoist-non-react-statics';
 import { SemverVersioning } from './versioning/SemverVersioning'
+import invokeTelemetryCallback from './invokeTelemetryCallback';
 
 const NativeCodePushModule = require("./native/NativeCodePush");
 let NativeCodePush = NativeCodePushModule.getNativeCodePush?.() ?? NativeCodePushModule.default;
@@ -83,7 +84,7 @@ async function decideLatestReleaseIsInRollout(versioning, clientId, onRolloutSki
 
   if (!inRollout) {
     log(`Skipping update due to rollout. Bucket ${bucket} is not smaller than rollout range ${latestReleaseInfo.rollout}.`);
-    onRolloutSkipped?.(latestVersion);
+    invokeTelemetryCallback('onRolloutSkipped', onRolloutSkipped, latestVersion);
   }
 
   return inRollout;
@@ -378,11 +379,11 @@ async function tryReportStatus(statusReport, retryOnAppResume) {
       const label = statusReport.package.label;
       if (statusReport.status === "DeploymentSucceeded") {
         log(`Reporting CodePush update success (${label})`);
-        sharedCodePushOptions?.onUpdateSuccess?.(label);
+        invokeTelemetryCallback('onUpdateSuccess', sharedCodePushOptions?.onUpdateSuccess, label);
       } else {
         log(`Reporting CodePush update rollback (${label})`);
         await nativeCodePush.setLatestRollbackInfo(statusReport.package.packageHash);
-        sharedCodePushOptions?.onUpdateRollback?.(label);
+        invokeTelemetryCallback('onUpdateRollback', sharedCodePushOptions?.onUpdateRollback, label);
       }
     }
 
@@ -565,20 +566,8 @@ async function syncInternal(options = {}, syncStatusChangeCallback, downloadProg
     ...options,
   };
 
-  /*
-   * A callback an app registered to observe how the update archives went must not be able
-   * to cost it an update, so it is isolated the way the other sync callbacks are: whatever
-   * it throws is logged and the install carries on. An app that registered none leaves the
-   * download exactly as it was before this option existed.
-   */
   const onUpdateArchiveResult = typeof syncOptions.onUpdateArchiveResult === "function"
-    ? (label, result) => {
-      try {
-        syncOptions.onUpdateArchiveResult(label, result);
-      } catch (error) {
-        log(`An error has occurred : ${error.stack}`);
-      }
-    }
+    ? (label, result) => invokeTelemetryCallback('onUpdateArchiveResult', syncOptions.onUpdateArchiveResult, label, result)
     : null;
 
   syncStatusChangeCallback = typeof syncStatusChangeCallback === "function"
@@ -630,14 +619,14 @@ async function syncInternal(options = {}, syncStatusChangeCallback, downloadProg
 
     const doDownloadAndInstall = async () => {
       syncStatusChangeCallback(CodePush.SyncStatus.DOWNLOADING_PACKAGE);
-      sharedCodePushOptions.onDownloadStart?.(remotePackageLabel);
+      invokeTelemetryCallback('onDownloadStart', sharedCodePushOptions.onDownloadStart, remotePackageLabel);
 
       const localPackage = await remotePackage.download(
         downloadProgressCallback,
         onUpdateArchiveResult && ((result) => onUpdateArchiveResult(remotePackageLabel, result)),
       );
 
-      sharedCodePushOptions.onDownloadSuccess?.(remotePackageLabel);
+      invokeTelemetryCallback('onDownloadSuccess', sharedCodePushOptions.onDownloadSuccess, remotePackageLabel);
 
       // Determine the correct install mode based on whether the update is mandatory or not.
       resolvedInstallMode = localPackage.isMandatory ? syncOptions.mandatoryInstallMode : syncOptions.installMode;
@@ -721,7 +710,7 @@ async function syncInternal(options = {}, syncStatusChangeCallback, downloadProg
     }
   } catch (error) {
     syncStatusChangeCallback(CodePush.SyncStatus.UNKNOWN_ERROR);
-    sharedCodePushOptions?.onSyncError?.(remotePackageLabel ?? 'unknown', error);
+    invokeTelemetryCallback('onSyncError', sharedCodePushOptions?.onSyncError, remotePackageLabel ?? 'unknown', error);
     log(error.message);
     throw error;
   }
@@ -752,26 +741,26 @@ let CodePush;
  *   updateChecker: updateChecker | undefined,
  *   setUpdateChecker(updateCheckerFunction: updateChecker | undefined): void,
  *
- *   onUpdateSuccess: (label: string) => void | undefined,
- *   setOnUpdateSuccess(onUpdateSuccessFunction: (label: string) => void | undefined): void,
+ *   onUpdateSuccess: (label: string) => void | Promise<void> | undefined,
+ *   setOnUpdateSuccess(onUpdateSuccessFunction: (label: string) => void | Promise<void> | undefined): void,
  *
- *   onUpdateRollback: (label: string) => void | undefined,
- *   setOnUpdateRollback(onUpdateRollbackFunction: (label: string) => void | undefined): void,
+ *   onUpdateRollback: (label: string) => void | Promise<void> | undefined,
+ *   setOnUpdateRollback(onUpdateRollbackFunction: (label: string) => void | Promise<void> | undefined): void,
  *
- *   onDownloadStart: (label: string) => void | undefined,
- *   setOnDownloadStart(onDownloadStartFunction: (label: string) => void | undefined): void,
+ *   onDownloadStart: (label: string) => void | Promise<void> | undefined,
+ *   setOnDownloadStart(onDownloadStartFunction: (label: string) => void | Promise<void> | undefined): void,
  *
- *   onDownloadSuccess: (label: string) => void | undefined,
- *   setOnDownloadSuccess(onDownloadSuccessFunction: (label: string) => void | undefined): void,
+ *   onDownloadSuccess: (label: string) => void | Promise<void> | undefined,
+ *   setOnDownloadSuccess(onDownloadSuccessFunction: (label: string) => void | Promise<void> | undefined): void,
  *
- *   onSyncError: (label: string, error: Error) => void | undefined,
- *   setOnSyncError(onSyncErrorFunction: (label: string, error: Error) => void | undefined): void,
+ *   onSyncError: (label: string, error: Error) => void | Promise<void> | undefined,
+ *   setOnSyncError(onSyncErrorFunction: (label: string, error: Error) => void | Promise<void> | undefined): void,
  *
- *   onRolloutSkipped: (label: string, error: Error) => void | undefined,
- *   setOnRolloutSkipped(onRolloutSkippedFunction: (label: string, error: Error) => void | undefined): void,
+ *   onRolloutSkipped: (label: string, error: Error) => void | Promise<void> | undefined,
+ *   setOnRolloutSkipped(onRolloutSkippedFunction: (label: string, error: Error) => void | Promise<void> | undefined): void,
  *
- *   onUpdateArchiveResult: (label: string, result: object) => void | undefined,
- *   setOnUpdateArchiveResult(onUpdateArchiveResultFunction: (label: string, result: object) => void | undefined): void,
+ *   onUpdateArchiveResult: (label: string, result: object) => void | Promise<void> | undefined,
+ *   setOnUpdateArchiveResult(onUpdateArchiveResultFunction: (label: string, result: object) => void | Promise<void> | undefined): void,
  * }}
  */
 const sharedCodePushOptions = {

package/src/CodePush.test.js

@@ -64,7 +64,7 @@ function diffRelease() {
  *        which only a download that had an archive to try comes back with.
  * @param installedPackage the CodePush update the app is running, if any.
  */
-function createNativeBridge({ updateArchiveResult, installedPackage } = {}) {
+function createNativeBridge({ updateArchiveResult, installedPackage, statusReport } = {}) {
   return {
     addDownloadProgressListener: jest.fn(() => ({ remove: jest.fn() })),
     downloadUpdate: jest.fn(async (updatePackage) => ({
@@ -78,9 +78,12 @@ function createNativeBridge({ updateArchiveResult, installedPackage } = {}) {
     // The rest of what a full `sync()` reaches for.
     InstallMode,
     clearPendingRestart: jest.fn(),
-    getNewStatusReport: jest.fn(async () => null),
+    getNewStatusReport: jest.fn(async () => statusReport ?? null),
     installUpdate: jest.fn(async () => {}),
     notifyApplicationReady: jest.fn(async () => {}),
+    recordStatusReported: jest.fn(),
+    saveStatusReportForRetry: jest.fn(),
+    setLatestRollbackInfo: jest.fn(async () => {}),
   };
 }
 
@@ -89,13 +92,13 @@ function createNativeBridge({ updateArchiveResult, installedPackage } = {}) {
  * native bridge live on the module itself - configured the way an app configures it: the
  * decorator registers the app-wide options, and every sync below is one the app asks for.
  *
- * @param onUpdateArchiveResult a callback the app registers on the decorator, as opposed to
- *        one it passes to a single `sync()` call.
+ * Callback options left after the bridge setup values are removed are registered on the
+ * decorator, the same way an app registers them.
  */
-function loadCodePush({ releaseHistory = {}, updateChecker, updateArchiveResult, onUpdateArchiveResult, installedPackage } = {}) {
+function loadCodePush({ releaseHistory = {}, updateChecker, updateArchiveResult, installedPackage, statusReport, ...codePushOptions } = {}) {
   jest.resetModules();
   const CodePush = require('./CodePush');
-  const nativeBridge = createNativeBridge({ updateArchiveResult, installedPackage });
+  const nativeBridge = createNativeBridge({ updateArchiveResult, installedPackage, statusReport });
 
   CodePush.setUpTestDependencies(
     null,
@@ -106,7 +109,7 @@ function loadCodePush({ releaseHistory = {}, updateChecker, updateArchiveResult,
     checkFrequency: CodePush.CheckFrequency.MANUAL,
     releaseHistoryFetcher: async () => releaseHistory,
     updateChecker,
-    onUpdateArchiveResult,
+    ...codePushOptions,
   });
 
   return { CodePush, nativeBridge };
@@ -492,6 +495,40 @@ describe('the update archive result of a sync', () => {
     expect(localPackage).toMatchObject({ label: LABEL, packageHash: PACKAGE_HASH });
   });
 
+  it('installs the update when the callback returns a rejected Promise', async () => {
+    const { CodePush, nativeBridge } = loadCodePush({
+      releaseHistory: patchedRelease(),
+      updateArchiveResult: APPLIED,
+    });
+    const onUpdateArchiveResult = jest.fn(async () => {
+      throw new Error('the telemetry request failed');
+    });
+
+    const syncStatus = await CodePush.sync({ onUpdateArchiveResult });
+    await Promise.resolve();
+
+    expect(syncStatus).toBe(CodePush.SyncStatus.UPDATE_INSTALLED);
+    expect(onUpdateArchiveResult).toHaveBeenCalledWith(LABEL, APPLIED);
+    expect(nativeBridge.installUpdate).toHaveBeenCalledTimes(1);
+  });
+
+  it('resolves a direct download when the callback returns a rejected Promise', async () => {
+    const { CodePush } = loadCodePush({
+      releaseHistory: patchedRelease(),
+      updateArchiveResult: APPLIED,
+    });
+    const onUpdateArchiveResult = jest.fn(async () => {
+      throw new Error('the telemetry request failed');
+    });
+
+    const remotePackage = await CodePush.checkForUpdate();
+    const localPackage = await remotePackage.download(undefined, onUpdateArchiveResult);
+    await Promise.resolve();
+
+    expect(onUpdateArchiveResult).toHaveBeenCalledWith(APPLIED);
+    expect(localPackage).toMatchObject({ label: LABEL, packageHash: PACKAGE_HASH });
+  });
+
   it('leaves the result off the package a download resolves with', async () => {
     const { CodePush } = loadCodePush({
       releaseHistory: patchedRelease(),
@@ -505,3 +542,110 @@ describe('the update archive result of a sync', () => {
     expect(localPackage).not.toHaveProperty('updateArchiveResult');
   });
 });
+
+describe('telemetry callback errors', () => {
+  it('installs the update when onDownloadStart throws', async () => {
+    const onDownloadStart = jest.fn(() => {
+      throw new Error('the telemetry client is unavailable');
+    });
+    const { CodePush, nativeBridge } = loadCodePush({
+      releaseHistory: fullOnlyRelease(),
+      onDownloadStart,
+    });
+
+    const syncStatus = await CodePush.sync();
+
+    expect(syncStatus).toBe(CodePush.SyncStatus.UPDATE_INSTALLED);
+    expect(onDownloadStart).toHaveBeenCalledWith(LABEL);
+    expect(nativeBridge.installUpdate).toHaveBeenCalledTimes(1);
+  });
+
+  it('installs the update when onDownloadSuccess returns a rejected Promise', async () => {
+    const onDownloadSuccess = jest.fn(async () => {
+      throw new Error('the telemetry request failed');
+    });
+    const { CodePush, nativeBridge } = loadCodePush({
+      releaseHistory: fullOnlyRelease(),
+      onDownloadSuccess,
+    });
+
+    const syncStatus = await CodePush.sync();
+    await Promise.resolve();
+
+    expect(syncStatus).toBe(CodePush.SyncStatus.UPDATE_INSTALLED);
+    expect(onDownloadSuccess).toHaveBeenCalledWith(LABEL);
+    expect(nativeBridge.installUpdate).toHaveBeenCalledTimes(1);
+  });
+
+  it('uses the next release when onRolloutSkipped throws', async () => {
+    const onRolloutSkipped = jest.fn(() => {
+      throw new Error('the telemetry client is unavailable');
+    });
+    const { CodePush } = loadCodePush({
+      releaseHistory: {
+        ...fullOnlyRelease(),
+        '1.0.2': {
+          ...fullOnlyRelease()[LABEL],
+          rollout: 0,
+          packageHash: 'b'.repeat(64),
+        },
+      },
+      onRolloutSkipped,
+    });
+
+    const remotePackage = await CodePush.checkForUpdate();
+
+    expect(onRolloutSkipped).toHaveBeenCalledWith('1.0.2');
+    expect(remotePackage.label).toBe(LABEL);
+  });
+
+  it('rejects with the original error when onSyncError throws', async () => {
+    const downloadError = new Error('the update download failed');
+    const onSyncError = jest.fn(() => {
+      throw new Error('the telemetry client is unavailable');
+    });
+    const { CodePush, nativeBridge } = loadCodePush({
+      releaseHistory: fullOnlyRelease(),
+      onSyncError,
+    });
+    nativeBridge.downloadUpdate.mockRejectedValueOnce(downloadError);
+
+    await expect(CodePush.sync()).rejects.toBe(downloadError);
+    expect(onSyncError).toHaveBeenCalledWith(LABEL, downloadError);
+  });
+
+  it('records a successful update when onUpdateSuccess throws', async () => {
+    const statusReport = {
+      status: 'DeploymentSucceeded',
+      package: { label: LABEL, packageHash: PACKAGE_HASH },
+    };
+    const onUpdateSuccess = jest.fn(() => {
+      throw new Error('the telemetry client is unavailable');
+    });
+    const { CodePush, nativeBridge } = loadCodePush({ statusReport, onUpdateSuccess });
+
+    await CodePush.notifyAppReady();
+
+    expect(onUpdateSuccess).toHaveBeenCalledWith(LABEL);
+    expect(nativeBridge.recordStatusReported).toHaveBeenCalledWith(statusReport);
+    expect(nativeBridge.saveStatusReportForRetry).not.toHaveBeenCalled();
+  });
+
+  it('records a rollback when onUpdateRollback returns a rejected Promise', async () => {
+    const statusReport = {
+      status: 'DeploymentFailed',
+      package: { label: LABEL, packageHash: PACKAGE_HASH },
+    };
+    const onUpdateRollback = jest.fn(async () => {
+      throw new Error('the telemetry request failed');
+    });
+    const { CodePush, nativeBridge } = loadCodePush({ statusReport, onUpdateRollback });
+
+    await CodePush.notifyAppReady();
+    await Promise.resolve();
+
+    expect(onUpdateRollback).toHaveBeenCalledWith(LABEL);
+    expect(nativeBridge.recordStatusReported).toHaveBeenCalledWith(statusReport);
+    expect(nativeBridge.saveStatusReportForRetry).not.toHaveBeenCalled();
+  });
+});

package/src/invokeTelemetryCallback.js

@@ -0,0 +1,18 @@
+const log = require("./logging");
+
+module.exports = function invokeTelemetryCallback(name, callback, ...args) {
+  if (typeof callback !== "function") return;
+
+  const logError = (error) => {
+    log(`The ${name} callback failed: ${error?.message ?? error}`);
+  };
+
+  try {
+    const result = callback(...args);
+    if (result && typeof result.then === "function") {
+      Promise.resolve(result).catch(logError);
+    }
+  } catch (error) {
+    logError(error);
+  }
+};

package/src/package-mixins.js

@@ -1,4 +1,4 @@
-const log = require("./logging");
+const invokeTelemetryCallback = require("./invokeTelemetryCallback");
 
 // This function is used to augment remote and local
 // package objects with additional functionality/properties
@@ -42,14 +42,10 @@ module.exports = (NativeCodePush) => {
           // taken off the package and reported on its own, leaving the package exactly what
           // the native side saved.
           const { updateArchiveResult, ...downloadedPackage } = downloadResult ?? {};
-          if (updateArchiveResult && updateArchiveResultCallback) {
+          if (updateArchiveResult) {
             // The result is an observation, so an observer that throws must not turn a
             // downloaded update into a failed one.
-            try {
-              updateArchiveResultCallback(updateArchiveResult);
-            } catch (error) {
-              log(`The update archive result callback threw: ${error?.message ?? error}`);
-            }
+            invokeTelemetryCallback('onUpdateArchiveResult', updateArchiveResultCallback, updateArchiveResult);
           }
 
           return { ...downloadedPackage, ...local };

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

@@ -211,27 +211,27 @@ export interface CodePushOptions extends SyncOptions {
     /**
      * Callback function that is called when the update installation succeeds.
      */
-    onUpdateSuccess?: (label: string) => void;
+    onUpdateSuccess?: (label: string) => void | Promise<void>;
     /**
      * Callback function that is called when the update rolled back.
      */
-    onUpdateRollback?: (label: string) => void;
+    onUpdateRollback?: (label: string) => void | Promise<void>;
     /**
      * Callback function that is called when download starts.
      */
-    onDownloadStart?: (label: string) => void;
+    onDownloadStart?: (label: string) => void | Promise<void>;
     /**
      * Callback function that is called when download finished successfully.
      */
-    onDownloadSuccess?: (label: string) => void;
+    onDownloadSuccess?: (label: string) => void | Promise<void>;
     /**
      * Callback function that is called when sync process failed.
      */
-    onSyncError?: (label: string, error: Error) => void;
+    onSyncError?: (label: string, error: Error) => void | Promise<void>;
     /**
      * Callback function that is called when rollout is skipped.
      */
-    onRolloutSkipped?: (label: string, error: Error) => void;
+    onRolloutSkipped?: (label: string, error: Error) => void | Promise<void>;
 }
 
 export interface DownloadProgress {
@@ -321,7 +321,7 @@ export interface RemotePackage extends Package {
      */
     download(
         downloadProgressCallback?: DownloadProgressCallback,
-        updateArchiveResultCallback?: (result: UpdateArchiveResult) => void,
+        updateArchiveResultCallback?: (result: UpdateArchiveResult) => void | Promise<void>,
     ): Promise<LocalPackage>;
 
     /**
@@ -404,7 +404,7 @@ export interface SyncOptions {
      * depends on the callback: registering none changes nothing, and one that throws is
      * logged and does not fail the download it is reporting on.
      */
-    onUpdateArchiveResult?: (label: string, result: UpdateArchiveResult) => void;
+    onUpdateArchiveResult?: (label: string, result: UpdateArchiveResult) => void | Promise<void>;
 
     /**
      * Specifies whether to ignore the update if the installation fails.