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

package/package.json

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

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.