@appzung/react-native-code-push 10.0.0-rc1 → 10.0.0

package/src/internals/getPromisifiedSdk.ts

@@ -0,0 +1,72 @@
+import type { Http, NativeUpdateNotification, Package, RemotePackage } from 'code-push/script/acquisition-sdk';
+import { AcquisitionSdk } from './AcquisitionSdk';
+import type { Configuration } from './types';
+
+export type PromisifiedSdkQueryPackage = Pick<Package, 'appVersion'> & { packageHash?: string };
+
+type PromisifiedSdk = {
+  queryUpdateWithCurrentPackage: (
+    queryPackage: PromisifiedSdkQueryPackage,
+  ) => Promise<RemotePackage | NativeUpdateNotification>;
+  reportStatusDeploy: (
+    deployedPackage?: Package,
+    status?: string,
+    previousLabelOrAppVersion?: string,
+    previousDeploymentKey?: string,
+  ) => Promise<void>;
+  reportStatusDownload: (downloadedPackage: Package) => Promise<void>;
+};
+
+export function getPromisifiedSdk(requestFetchAdapter: Http.Requester, config: Configuration): PromisifiedSdk {
+  // TODO MIGRATION Temporary retro-compat while we still use code-push module
+  config.deploymentKey = config.releaseChannelPublicId;
+
+  const sdk = new AcquisitionSdk(requestFetchAdapter, config);
+
+  return {
+    queryUpdateWithCurrentPackage: (queryPackage) => {
+      return new Promise<RemotePackage | NativeUpdateNotification>((resolve, reject) => {
+        // @ts-expect-error sdk typing is wrong
+        AcquisitionSdk.prototype.queryUpdateWithCurrentPackage.call(sdk, queryPackage, (err, update) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+
+          resolve(update);
+        });
+      });
+    },
+    reportStatusDeploy: (deployedPackage, status, previousLabelOrAppVersion, previousReleaseChannelPublicId) => {
+      return new Promise<void>((resolve, reject) => {
+        AcquisitionSdk.prototype.reportStatusDeploy.call(
+          sdk,
+          deployedPackage,
+          status,
+          previousLabelOrAppVersion,
+          previousReleaseChannelPublicId,
+          (err) => {
+            if (err) {
+              reject(err);
+              return;
+            }
+
+            resolve();
+          },
+        );
+      });
+    },
+    reportStatusDownload: (downloadedPackage) => {
+      return new Promise<void>((resolve, reject) => {
+        AcquisitionSdk.prototype.reportStatusDownload.call(sdk, downloadedPackage, (err) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+
+          resolve();
+        });
+      });
+    },
+  };
+}

package/src/internals/shouldUpdateBeIgnored.ts

@@ -0,0 +1,76 @@
+import type { RemotePackage, RollbackRetryOptions, SyncOptions } from '../types';
+import { NativeRNAppZungCodePushModule } from './NativeRNAppZungCodePushModule';
+import type { LatestRollbackInfo } from './types';
+import { log } from './utils/log';
+
+const DEFAULT_ROLLBACK_RETRY_OPTIONS = {
+  delayInHours: 24,
+  maxRetryAttempts: 1,
+};
+
+function validateLatestRollbackInfo(latestRollbackInfo: LatestRollbackInfo, packageHash: string) {
+  return (
+    latestRollbackInfo &&
+    latestRollbackInfo.time &&
+    latestRollbackInfo.count &&
+    latestRollbackInfo.packageHash &&
+    latestRollbackInfo.packageHash === packageHash
+  );
+}
+
+function validateRollbackRetryOptions(rollbackRetryOptions: RollbackRetryOptions) {
+  if (typeof rollbackRetryOptions.delayInHours !== 'number') {
+    log("The 'delayInHours' rollback retry parameter must be a number.");
+    return false;
+  }
+
+  if (typeof rollbackRetryOptions.maxRetryAttempts !== 'number') {
+    log("The 'maxRetryAttempts' rollback retry parameter must be a number.");
+    return false;
+  }
+
+  if (rollbackRetryOptions.maxRetryAttempts < 1) {
+    log("The 'maxRetryAttempts' rollback retry parameter cannot be less then 1.");
+    return false;
+  }
+
+  return true;
+}
+
+export async function shouldUpdateBeIgnored(remotePackage: RemotePackage | null | undefined, syncOptions: SyncOptions) {
+  const isFailedPackage = remotePackage && remotePackage.failedInstall;
+  if (!isFailedPackage || !syncOptions.ignoreFailedUpdates) {
+    return false;
+  }
+
+  if (!syncOptions.rollbackRetryOptions) {
+    return true;
+  }
+
+  const rollbackRetryOptions: Required<RollbackRetryOptions> =
+    typeof syncOptions.rollbackRetryOptions === 'object'
+      ? {
+          ...DEFAULT_ROLLBACK_RETRY_OPTIONS,
+          ...syncOptions.rollbackRetryOptions,
+        }
+      : DEFAULT_ROLLBACK_RETRY_OPTIONS;
+
+  if (!validateRollbackRetryOptions(rollbackRetryOptions)) {
+    return true;
+  }
+
+  const latestRollbackInfo = await NativeRNAppZungCodePushModule.getLatestRollbackInfo();
+  if (!validateLatestRollbackInfo(latestRollbackInfo, remotePackage.packageHash)) {
+    log('The latest rollback info is not valid.');
+    return true;
+  }
+
+  const { delayInHours, maxRetryAttempts } = rollbackRetryOptions;
+  const hoursSinceLatestRollback = (Date.now() - latestRollbackInfo.time) / (1000 * 60 * 60);
+  if (hoursSinceLatestRollback >= delayInHours && maxRetryAttempts >= latestRollbackInfo.count) {
+    log('Previous rollback should be ignored due to rollback retry options.');
+    return false;
+  }
+
+  return true;
+}

package/src/internals/types.ts

@@ -0,0 +1,18 @@
+import type { Configuration as BaseConfiguration } from 'code-push/script/acquisition-sdk';
+
+export interface Configuration extends BaseConfiguration {
+  releaseChannelPublicId: string;
+  packageHash?: string;
+}
+
+export interface LatestRollbackInfo {
+  time: number;
+  count: number;
+  packageHash: string;
+}
+
+type FunctionPropertyNames<T> = {
+  [K in keyof T]: T[K] extends Function ? K : never;
+}[keyof T];
+
+export type OmitFunctions<T extends object> = Omit<T, FunctionPropertyNames<T>>;

package/{logging.js → src/internals/utils/log.ts}

@@ -1,6 +1,4 @@
 /* Logs messages to console with the [CodePush] prefix */
-function log(message) {
+export function log(message: string): void {
   console.log(`[CodePush] ${message}`);
 }
-
-module.exports = log;

package/src/internals/utils/request-fetch-adapter.ts

@@ -0,0 +1,58 @@
+import { Http } from 'code-push/script/acquisition-sdk';
+import { version } from '../version';
+
+interface ResponseCallback {
+  (error: Error | null, response?: Http.Response): void;
+}
+
+export const requestFetchAdapter: Http.Requester = {
+  // @ts-expect-error SDK typing is wrong about error callback
+  async request(
+    verb: Http.Verb,
+    url: string,
+    requestBody: any | ResponseCallback,
+    callback?: ResponseCallback,
+  ): Promise<void> {
+    if (typeof requestBody === 'function') {
+      callback = requestBody;
+      requestBody = null;
+    }
+
+    const headers = {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+      'X-CodePush-Plugin-Name': '@appzung/react-native-code-push',
+      'X-CodePush-Plugin-Version': version,
+    };
+
+    if (requestBody && typeof requestBody === 'object') {
+      requestBody = JSON.stringify(requestBody);
+    }
+
+    try {
+      const response = await fetch(url, {
+        method: getHttpMethodName(verb),
+        headers: headers,
+        body: requestBody,
+      });
+
+      const statusCode = response.status;
+      const body = await response.text();
+      callback!(null, { statusCode, body });
+    } catch (err) {
+      callback!(err as Error);
+    }
+  },
+};
+
+function getHttpMethodName(verb: Http.Verb): string {
+  // Note: This should stay in sync with the enum definition in
+  // https://github.com/microsoft/code-push/blob/master/sdk/script/acquisition-sdk.ts#L6
+  const methodName = ['GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'TRACE', 'OPTIONS', 'CONNECT', 'PATCH'][verb];
+
+  if (!methodName) {
+    throw new Error('Invalid method name verb');
+  }
+
+  return methodName;
+}

package/src/internals/version.ts

@@ -0,0 +1,2 @@
+// Generated by genversion.
+export const version = '10.0.0';

package/src/notifyAppReady.ts

@@ -0,0 +1,94 @@
+import { AppState, type NativeEventSubscription } from 'react-native';
+import { NativeRNAppZungCodePushModule } from './internals/NativeRNAppZungCodePushModule';
+import { getConfiguration } from './internals/getConfiguration';
+import { getPromisifiedSdk } from './internals/getPromisifiedSdk';
+import { log } from './internals/utils/log';
+import { requestFetchAdapter } from './internals/utils/request-fetch-adapter';
+import type { StatusReport } from './types';
+
+/**
+ * Notifies the CodePush runtime that an installed update is considered successful.
+ */
+export const notifyAppReady = (() => {
+  // This ensures that notifyApplicationReadyInternal is only called once
+  // in the lifetime of this module instance.
+  let notifyApplicationReadyPromise: Promise<StatusReport | void> | undefined;
+
+  return () => {
+    if (!notifyApplicationReadyPromise) {
+      notifyApplicationReadyPromise = notifyApplicationReadyInternal();
+    }
+
+    return notifyApplicationReadyPromise;
+  };
+})();
+
+async function notifyApplicationReadyInternal() {
+  await NativeRNAppZungCodePushModule.notifyApplicationReady();
+  const statusReport = await NativeRNAppZungCodePushModule.getNewStatusReport();
+  statusReport && tryReportStatus(statusReport); // Don't wait for this to complete.
+
+  return statusReport;
+}
+
+async function tryReportStatus(statusReport: StatusReport, retryOnAppResume?: NativeEventSubscription) {
+  const config = await getConfiguration();
+  const previousLabelOrAppVersion = statusReport.previousLabelOrAppVersion;
+  const previousReleaseChannelPublicId = statusReport.previousReleaseChannelPublicId || config.releaseChannelPublicId;
+  try {
+    if (statusReport.appVersion) {
+      log(`Reporting binary update (${statusReport.appVersion})`);
+
+      if (!config.releaseChannelPublicId) {
+        throw new Error('Release channel is missing');
+      }
+
+      const sdk = getPromisifiedSdk(requestFetchAdapter, config);
+      await sdk.reportStatusDeploy(
+        /* deployedPackage */ undefined,
+        /* status */ undefined,
+        previousLabelOrAppVersion,
+        previousReleaseChannelPublicId,
+      );
+    } else {
+      if (!statusReport.package) {
+        throw new Error('Missing package in status report');
+      }
+
+      const label = statusReport.package.label;
+      if (statusReport.status === 'DeploymentSucceeded') {
+        log(`Reporting CodePush update success (${label})`);
+      } else {
+        log(`Reporting CodePush update rollback (${label})`);
+        await NativeRNAppZungCodePushModule.setLatestRollbackInfo(statusReport.package.packageHash);
+      }
+
+      config.releaseChannelPublicId = statusReport.package.releaseChannelPublicId;
+      const sdk = getPromisifiedSdk(requestFetchAdapter, config);
+      await sdk.reportStatusDeploy(
+        { ...statusReport.package, deploymentKey: statusReport.package.releaseChannelPublicId },
+        statusReport.status,
+        previousLabelOrAppVersion,
+        previousReleaseChannelPublicId,
+      );
+    }
+
+    NativeRNAppZungCodePushModule.recordStatusReported(statusReport);
+    retryOnAppResume && retryOnAppResume.remove();
+  } catch (e) {
+    log(`Report status failed: ${JSON.stringify(statusReport)}`);
+    NativeRNAppZungCodePushModule.saveStatusReportForRetry(statusReport);
+    // Try again when the app resumes
+    if (!retryOnAppResume) {
+      const resumeListener = AppState.addEventListener('change', async (newState) => {
+        if (newState !== 'active') return;
+        const refreshedStatusReport = await NativeRNAppZungCodePushModule.getNewStatusReport();
+        if (refreshedStatusReport) {
+          tryReportStatus(refreshedStatusReport, resumeListener);
+        } else {
+          resumeListener && resumeListener.remove();
+        }
+      });
+    }
+  }
+}

package/src/reactNative.d.ts

@@ -0,0 +1,34 @@
+declare module 'react-native' {
+  export type PlatformStatic = {
+    OS: 'ios' | 'android' | 'windows';
+  };
+  export const Platform: PlatformStatic;
+
+  export interface NativeEventSubscription {
+    remove(): void;
+  }
+  export class NativeEventEmitter {
+    constructor(nativeModule?: any);
+    addListener(eventType: string, listener: (event: any) => void, context?: Object): NativeEventSubscription;
+  }
+
+  type AppStateStatus = string;
+  export interface AppStateStatic {
+    currentState: AppStateStatus;
+    addEventListener(type: AppStateEvent, listener: (state: AppStateStatus) => void): NativeEventSubscription;
+  }
+  export const AppState: AppStateStatic;
+
+  export interface AlertButton {
+    text?: string;
+    onPress?: () => void;
+  }
+  interface AlertStatic {
+    alert(title: string, message?: string, buttons?: AlertButton[]): void;
+  }
+  export const Alert: AlertStatic;
+
+  export interface TurboModule {
+    getConstants?(): {};
+  }
+}

package/src/restartApp.ts

@@ -0,0 +1,10 @@
+import { NativeRNAppZungCodePushModule } from './internals/NativeRNAppZungCodePushModule';
+
+/**
+ * Immediately restarts the app.
+ *
+ * @param onlyIfUpdateIsPending Indicates whether you want the restart to no-op if there isn't currently a pending update.
+ */
+export async function restartApp(onlyIfUpdateIsPending = false) {
+  NativeRNAppZungCodePushModule.restartApp(onlyIfUpdateIsPending);
+}

package/src/sync.ts

@@ -0,0 +1,272 @@
+import { Alert, type AlertButton, Platform } from 'react-native';
+import { checkForUpdate } from './checkForUpdates';
+import { InstallMode } from './enums/InstallMode.enum';
+import { SyncStatus } from './enums/SyncStatus.enum';
+import { getCurrentPackage } from './internals/getCurrentPackage';
+import { shouldUpdateBeIgnored } from './internals/shouldUpdateBeIgnored';
+import { log } from './internals/utils/log';
+import { notifyAppReady } from './notifyAppReady';
+import type {
+  DownloadProgressCallback,
+  HandleBinaryVersionMismatchCallback,
+  SyncOptions,
+  SyncStatusChangedCallback,
+  UpdateDialog,
+} from './types';
+
+/**
+ * Represents the default settings that will be used by the sync method if
+ * an update dialog is configured to be displayed.
+ */
+export const DEFAULT_UPDATE_DIALOG: UpdateDialog = {
+  appendReleaseDescription: false,
+  descriptionPrefix: ' Description: ',
+  mandatoryContinueButtonLabel: 'Continue',
+  mandatoryUpdateMessage: 'An update is available that must be installed.',
+  optionalIgnoreButtonLabel: 'Ignore',
+  optionalInstallButtonLabel: 'Install',
+  optionalUpdateMessage: 'An update is available. Would you like to install it?',
+  title: 'Update available',
+};
+
+/*
+ * The syncInternal method provides a simple, one-line experience for
+ * incorporating the check, download and installation of an update.
+ *
+ * It simply composes the existing API methods together and adds additional
+ * support for respecting mandatory updates, ignoring previously failed
+ * releases, and displaying a standard confirmation UI to the end-user
+ * when an update is available.
+ */
+async function syncInternal(
+  options?: SyncOptions,
+  syncStatusChangeCallback?: SyncStatusChangedCallback,
+  downloadProgressCallback?: DownloadProgressCallback,
+  handleBinaryVersionMismatchCallback?: HandleBinaryVersionMismatchCallback,
+): Promise<SyncStatus> {
+  let resolvedInstallMode: InstallMode | undefined;
+  const syncOptions: SyncOptions = {
+    releaseChannelPublicId: undefined,
+    ignoreFailedUpdates: true,
+    rollbackRetryOptions: undefined,
+    installMode: InstallMode.ON_NEXT_RESTART,
+    mandatoryInstallMode: InstallMode.IMMEDIATE,
+    minimumBackgroundDuration: 0,
+    updateDialog: undefined,
+    ...options,
+  };
+
+  syncStatusChangeCallback =
+    typeof syncStatusChangeCallback === 'function'
+      ? syncStatusChangeCallback
+      : (syncStatus: SyncStatus) => {
+          switch (syncStatus) {
+            case SyncStatus.CHECKING_FOR_UPDATE:
+              log('Checking for update.');
+              break;
+            case SyncStatus.AWAITING_USER_ACTION:
+              log('Awaiting user action.');
+              break;
+            case SyncStatus.DOWNLOADING_PACKAGE:
+              log('Downloading package.');
+              break;
+            case SyncStatus.INSTALLING_UPDATE:
+              log('Installing update.');
+              break;
+            case SyncStatus.UP_TO_DATE:
+              log('App is up to date.');
+              break;
+            case SyncStatus.UPDATE_IGNORED:
+              log('User cancelled the update.');
+              break;
+            case SyncStatus.UPDATE_INSTALLED:
+              if (resolvedInstallMode == InstallMode.ON_NEXT_RESTART) {
+                log('Update is installed and will be run on the next app restart.');
+              } else if (resolvedInstallMode == InstallMode.ON_NEXT_RESUME) {
+                if (!!syncOptions.minimumBackgroundDuration) {
+                  log(
+                    `Update is installed and will be run after the app has been in the background for at least ${syncOptions.minimumBackgroundDuration} seconds.`,
+                  );
+                } else {
+                  log('Update is installed and will be run when the app next resumes.');
+                }
+              }
+              break;
+            case SyncStatus.UNKNOWN_ERROR:
+              log('An unknown error occurred.');
+              break;
+          }
+        };
+
+  try {
+    await notifyAppReady();
+
+    syncStatusChangeCallback(SyncStatus.CHECKING_FOR_UPDATE);
+    const remotePackage = await checkForUpdate(syncOptions.releaseChannelPublicId, handleBinaryVersionMismatchCallback);
+
+    const doDownloadAndInstall = async () => {
+      if (!remotePackage) {
+        throw new Error('remotePackage should be defined');
+      }
+
+      syncStatusChangeCallback(SyncStatus.DOWNLOADING_PACKAGE);
+      const localPackage = await remotePackage.download(downloadProgressCallback);
+
+      // Determine the correct install mode based on whether the update is mandatory or not.
+      resolvedInstallMode = localPackage.isMandatory ? syncOptions.mandatoryInstallMode : syncOptions.installMode;
+
+      syncStatusChangeCallback(SyncStatus.INSTALLING_UPDATE);
+      await localPackage.install(resolvedInstallMode, syncOptions.minimumBackgroundDuration, () => {
+        syncStatusChangeCallback(SyncStatus.UPDATE_INSTALLED);
+      });
+
+      return SyncStatus.UPDATE_INSTALLED;
+    };
+
+    const updateShouldBeIgnored = await shouldUpdateBeIgnored(remotePackage, syncOptions);
+
+    if (!remotePackage || updateShouldBeIgnored) {
+      if (updateShouldBeIgnored) {
+        log('An update is available, but it is being ignored due to having been previously rolled back.');
+      }
+
+      const currentPackage = await getCurrentPackage();
+      if (currentPackage && currentPackage.isPending) {
+        syncStatusChangeCallback(SyncStatus.UPDATE_INSTALLED);
+        return SyncStatus.UPDATE_INSTALLED;
+      } else {
+        syncStatusChangeCallback(SyncStatus.UP_TO_DATE);
+        return SyncStatus.UP_TO_DATE;
+      }
+    } else if (syncOptions.updateDialog) {
+      const updateDialogConfig =
+        typeof syncOptions.updateDialog !== 'object'
+          ? DEFAULT_UPDATE_DIALOG
+          : { ...DEFAULT_UPDATE_DIALOG, ...syncOptions.updateDialog };
+
+      return await new Promise((resolve, reject) => {
+        let message: string | undefined;
+        let installButtonText: string | undefined;
+
+        const dialogButtons: AlertButton[] = [];
+
+        if (remotePackage.isMandatory) {
+          message = updateDialogConfig.mandatoryUpdateMessage;
+          installButtonText = updateDialogConfig.mandatoryContinueButtonLabel;
+        } else {
+          message = updateDialogConfig.optionalUpdateMessage;
+          installButtonText = updateDialogConfig.optionalInstallButtonLabel;
+          // Since this is an optional update, add a button
+          // to allow the end-user to ignore it
+          dialogButtons.push({
+            text: updateDialogConfig.optionalIgnoreButtonLabel ?? '',
+            onPress: () => {
+              syncStatusChangeCallback(SyncStatus.UPDATE_IGNORED);
+              resolve(SyncStatus.UPDATE_IGNORED);
+            },
+          });
+        }
+
+        // Since the install button should be placed to the
+        // right of any other button, add it last
+        dialogButtons.push({
+          text: installButtonText ?? '',
+          onPress: () => {
+            doDownloadAndInstall().then(resolve, reject);
+          },
+        });
+
+        // If the update has a description, and the developer
+        // explicitly chose to display it, then set that as the message
+        if (updateDialogConfig.appendReleaseDescription && remotePackage.description) {
+          message += `${updateDialogConfig.descriptionPrefix} ${remotePackage.description}`;
+        }
+
+        syncStatusChangeCallback(SyncStatus.AWAITING_USER_ACTION);
+        Alert.alert(
+          updateDialogConfig.title || '',
+          message || '',
+          Platform.OS === 'android' ? [...dialogButtons.reverse()] : dialogButtons,
+        );
+      });
+    } else {
+      return await doDownloadAndInstall();
+    }
+  } catch (error) {
+    syncStatusChangeCallback(SyncStatus.UNKNOWN_ERROR);
+    log(
+      error != null && typeof error === 'object' && 'message' in error && typeof error.message === 'string'
+        ? error.message
+        : 'Unknown',
+    );
+    throw error;
+  }
+}
+
+/**
+ * Allows checking for an update, downloading it and installing it, all with a single call.
+ *
+ * @param options Options used to configure the end-user update experience (e.g. show a prompt?, install the update immediately?).
+ * @param syncStatusChangedCallback An optional callback that allows tracking the status of the sync operation, as opposed to simply checking the resolved state via the returned Promise.
+ * @param downloadProgressCallback An optional callback that allows tracking the progress of an update while it is being downloaded.
+ * @param handleBinaryVersionMismatchCallback An optional callback for handling target binary version mismatch
+ */
+export const sync = (() => {
+  // This function allows only one syncInternal operation to proceed at any given time.
+  // Parallel calls to sync() while one is ongoing yields CodePush.SyncStatus.SYNC_IN_PROGRESS.
+
+  let syncInProgress = false;
+  const setSyncCompleted = () => {
+    syncInProgress = false;
+  };
+
+  return (
+    options?: SyncOptions,
+    syncStatusChangeCallback?: SyncStatusChangedCallback,
+    downloadProgressCallback?: DownloadProgressCallback,
+    handleBinaryVersionMismatchCallback?: HandleBinaryVersionMismatchCallback,
+  ): Promise<SyncStatus> => {
+    let syncStatusCallbackWithTryCatch: SyncStatusChangedCallback | undefined;
+    let downloadProgressCallbackWithTryCatch: DownloadProgressCallback | undefined;
+
+    if (typeof syncStatusChangeCallback === 'function') {
+      syncStatusCallbackWithTryCatch = (...args) => {
+        try {
+          syncStatusChangeCallback(...args);
+        } catch (error) {
+          log(`An error has occurred : ${error instanceof Error ? error.stack : 'unknown'}`);
+        }
+      };
+    }
+
+    if (typeof downloadProgressCallback === 'function') {
+      downloadProgressCallbackWithTryCatch = (...args) => {
+        try {
+          downloadProgressCallback(...args);
+        } catch (error) {
+          log(`An error has occurred: ${error instanceof Error ? error.stack : 'unknown'}`);
+        }
+      };
+    }
+
+    if (syncInProgress) {
+      typeof syncStatusCallbackWithTryCatch === 'function'
+        ? syncStatusCallbackWithTryCatch(SyncStatus.SYNC_IN_PROGRESS)
+        : log('Sync already in progress.');
+      return Promise.resolve(SyncStatus.SYNC_IN_PROGRESS);
+    }
+
+    syncInProgress = true;
+
+    const syncPromise = syncInternal(
+      options,
+      syncStatusCallbackWithTryCatch,
+      downloadProgressCallbackWithTryCatch,
+      handleBinaryVersionMismatchCallback,
+    );
+
+    syncPromise.then(setSyncCompleted).catch(setSyncCompleted);
+
+    return syncPromise;
+  };
+})();