@algocare/react-native-code-push 10.3.2 → 11.0.0

package/CodePush.js

@@ -1,13 +1,17 @@
-import { Alert } from "./AlertAdapter";
-import { AppState, Platform } from "react-native";
-import log from "./logging";
-import hoistStatics from 'hoist-non-react-statics';
+import { Alert } from './AlertAdapter'
+import { AppState, Platform } from 'react-native'
+import log from './logging'
+import hoistStatics from 'hoist-non-react-statics'
 import { SemverVersioning } from './versioning/SemverVersioning'
 
-let NativeCodePush = require("react-native").NativeModules.CodePush;
-const PackageMixins = require("./package-mixins")(NativeCodePush);
+let NativeCodePush = require('react-native').NativeModules.CodePush
+const PackageMixins = require('./package-mixins')(NativeCodePush)
 
-async function checkForUpdate(deploymentKey = null, handleBinaryVersionMismatchCallback = null) {
+async function checkForUpdate(
+  prNumber,
+  packageHash,
+  handleBinaryVersionMismatchCallback = null
+) {
   /*
    * Before we ask the server if an update exists, we
    * need to retrieve three pieces of information from the
@@ -17,7 +21,7 @@ async function checkForUpdate(deploymentKey = null, handleBinaryVersionMismatchC
    * for their specific deployment and version and which are actually
    * different from the CodePush update they have already installed.
    */
-  const nativeConfig = await getConfiguration();
+  const nativeConfig = await getConfiguration()
   /*
    * If a deployment key was explicitly provided,
    * then let's override the one we retrieved
@@ -25,10 +29,10 @@ async function checkForUpdate(deploymentKey = null, handleBinaryVersionMismatchC
    * dynamically "redirecting" end-users at different
    * deployments (e.g. an early access deployment for insiders).
    */
-  const config = deploymentKey ? { ...nativeConfig, ...{ deploymentKey } } : nativeConfig;
+  const config = nativeConfig
 
   // Use dynamically overridden getCurrentPackage() during tests.
-  const localPackage = await module.exports.getCurrentPackage();
+  const localPackage = await module.exports.getCurrentPackage()
 
   /*
    * If the app has a previously installed update, and that update
@@ -38,13 +42,13 @@ async function checkForUpdate(deploymentKey = null, handleBinaryVersionMismatchC
    * to send the app version to the server, since we are interested
    * in any updates for current binary version, regardless of hash.
    */
-  let queryPackage;
+  let queryPackage
   if (localPackage) {
-    queryPackage = localPackage;
+    queryPackage = localPackage
   } else {
-    queryPackage = { appVersion: config.appVersion };
-    if (Platform.OS === "ios" && config.packageHash) {
-      queryPackage.packageHash = config.packageHash;
+    queryPackage = { appVersion: config.appVersion }
+    if (Platform.OS === 'ios' && config.packageHash) {
+      queryPackage.packageHash = config.packageHash
     }
   }
 
@@ -58,43 +62,60 @@ async function checkForUpdate(deploymentKey = null, handleBinaryVersionMismatchC
         is_companion: config.ignoreAppVersion,
         label: queryPackage.label,
         client_unique_id: config.clientUniqueId,
-      };
+      }
 
       /**
        * @type {updateChecker|undefined}
        * @deprecated
        */
-      const updateChecker = sharedCodePushOptions.updateChecker;
+      const updateChecker = sharedCodePushOptions.updateChecker
       if (updateChecker) {
-        const { update_info } = await updateChecker(updateRequest);
+        const { update_info } = await updateChecker(updateRequest)
 
-        return mapToRemotePackageMetadata(update_info, config.deploymentKey);
+        return mapToRemotePackageMetadata(update_info, config.deploymentKey)
       } else {
         /**
          * `releaseHistory`
          * @type {ReleaseHistoryInterface}
          */
-        const releaseHistory = await sharedCodePushOptions.releaseHistoryFetcher(updateRequest);
+        const releaseHistory =
+          await sharedCodePushOptions.releaseHistoryFetcher(updateRequest)
+
+        const filteredReleaseHistory = Object.entries(releaseHistory)
+          .filter(([key]) => key.includes(prNumber))
+          .reduce((acc, [key, value]) => {
+            const version = key.split('-')[1]
+            acc[version] = value
+            return acc
+          }, {})
+
+        const _releaseHistory = packageHash
+          ? filteredReleaseHistory
+          : releaseHistory
 
         /**
          * `runtimeVersion`
          * The version of currently running CodePush update. (It can be undefined if the app is running without CodePush update.)
          * @type {string|undefined}
          */
-        const runtimeVersion = updateRequest.label;
+        const runtimeVersion = packageHash
+          ? updateRequest.label.split('-')[1]
+          : updateRequest.label
 
-        const versioning = new SemverVersioning(releaseHistory);
+        const versioning = new SemverVersioning(_releaseHistory)
 
-        const shouldRollbackToBinary = versioning.shouldRollbackToBinary(runtimeVersion)
+        const shouldRollbackToBinary =
+          versioning.shouldRollbackToBinary(runtimeVersion)
         if (shouldRollbackToBinary) {
           // Reset to latest major version and restart
-          CodePush.clearUpdates();
-          CodePush.allowRestart();
-          CodePush.restartApp();
+          CodePush.clearUpdates()
+          CodePush.allowRestart()
+          CodePush.restartApp()
         }
 
-        const [latestVersion, latestReleaseInfo] = versioning.findLatestRelease();
-        const isMandatory = versioning.checkIsMandatory(runtimeVersion);
+        const [latestVersion, latestReleaseInfo] =
+          versioning.findLatestRelease()
+        const isMandatory = versioning.checkIsMandatory(runtimeVersion)
 
         /**
          * Convert the update information decided from `ReleaseHistoryInterface` to be passed to the library core (original CodePush library).
@@ -128,15 +149,15 @@ async function checkForUpdate(deploymentKey = null, handleBinaryVersionMismatchC
           should_run_binary_version: false,
         }
 
-        return mapToRemotePackageMetadata(updateInfo, config.deploymentKey);
+        return mapToRemotePackageMetadata(updateInfo, config.deploymentKey)
       }
     } catch (error) {
-      log(`An error has occurred at update checker :`);
+      log(`An error has occurred at update checker :`)
       console.error(error)
       // update will not happen
-      return undefined;
+      return undefined
     }
-  })();
+  })()
 
   /*
    * There are four cases where checkForUpdate will resolve to null:
@@ -156,22 +177,33 @@ async function checkForUpdate(deploymentKey = null, handleBinaryVersionMismatchC
    *    because we want to avoid having to install diff updates against the binary's
    *    version, which we can't do yet on Android.
    */
-  if (!update || update.updateAppVersion ||
-      localPackage && (update.packageHash === localPackage.packageHash) ||
-      (!localPackage || localPackage._isDebugOnly) && config.packageHash === update.packageHash) {
+  if (
+    !update ||
+    update.updateAppVersion ||
+    (localPackage && update.packageHash === localPackage.packageHash) ||
+    ((!localPackage || localPackage._isDebugOnly) &&
+      config.packageHash === update.packageHash)
+  ) {
     if (update && update.updateAppVersion) {
-      log("An update is available but it is not targeting the binary version of your app.");
-      if (handleBinaryVersionMismatchCallback && typeof handleBinaryVersionMismatchCallback === "function") {
+      log(
+        'An update is available but it is not targeting the binary version of your app.'
+      )
+      if (
+        handleBinaryVersionMismatchCallback &&
+        typeof handleBinaryVersionMismatchCallback === 'function'
+      ) {
         handleBinaryVersionMismatchCallback(update)
       }
     }
 
-    return null;
+    return null
   } else {
-    const remotePackage = { ...update, ...PackageMixins.remote() };
-    remotePackage.failedInstall = await NativeCodePush.isFailedUpdate(remotePackage.packageHash);
-    remotePackage.deploymentKey = deploymentKey || nativeConfig.deploymentKey;
-    return remotePackage;
+    const remotePackage = { ...update, ...PackageMixins.remote() }
+    remotePackage.failedInstall = await NativeCodePush.isFailedUpdate(
+      remotePackage.packageHash
+    )
+    remotePackage.deploymentKey = nativeConfig.deploymentKey
+    return remotePackage
   }
 }
 
@@ -182,12 +214,12 @@ async function checkForUpdate(deploymentKey = null, handleBinaryVersionMismatchC
  */
 function mapToRemotePackageMetadata(updateInfo, deploymentKey) {
   if (!updateInfo) {
-    return null;
+    return null
   } else if (!updateInfo.download_url) {
-    log("download_url is missed in the release history.");
-    return null;
+    log('download_url is missed in the release history.')
+    return null
   } else if (!updateInfo.is_available) {
-    return null;
+    return null
   }
 
   // refer to `RemotePackage` type inside code-push SDK
@@ -200,220 +232,255 @@ function mapToRemotePackageMetadata(updateInfo, deploymentKey) {
     packageHash: updateInfo.package_hash ?? '',
     packageSize: updateInfo.package_size ?? 0,
     downloadUrl: updateInfo.download_url ?? '',
-  };
+  }
 }
 
 const getConfiguration = (() => {
-  let config;
+  let config
   return async function getConfiguration() {
     if (config) {
-      return config;
+      return config
     } else if (testConfig) {
-      return testConfig;
+      return testConfig
     } else {
-      config = await NativeCodePush.getConfiguration();
-      return config;
+      config = await NativeCodePush.getConfiguration()
+      return config
     }
   }
-})();
+})()
 
 async function getCurrentPackage() {
-  return await getUpdateMetadata(CodePush.UpdateState.LATEST);
+  return await getUpdateMetadata(CodePush.UpdateState.LATEST)
 }
 
 async function getUpdateMetadata(updateState) {
-  let updateMetadata = await NativeCodePush.getUpdateMetadata(updateState || CodePush.UpdateState.RUNNING);
+  let updateMetadata = await NativeCodePush.getUpdateMetadata(
+    updateState || CodePush.UpdateState.RUNNING
+  )
   if (updateMetadata) {
-    updateMetadata = {...PackageMixins.local, ...updateMetadata};
-    updateMetadata.failedInstall = await NativeCodePush.isFailedUpdate(updateMetadata.packageHash);
-    updateMetadata.isFirstRun = await NativeCodePush.isFirstRun(updateMetadata.packageHash);
+    updateMetadata = { ...PackageMixins.local, ...updateMetadata }
+    updateMetadata.failedInstall = await NativeCodePush.isFailedUpdate(
+      updateMetadata.packageHash
+    )
+    updateMetadata.isFirstRun = await NativeCodePush.isFirstRun(
+      updateMetadata.packageHash
+    )
   }
-  return updateMetadata;
+  return updateMetadata
 }
 
 // This ensures that notifyApplicationReadyInternal is only called once
 // in the lifetime of this module instance.
 const notifyApplicationReady = (() => {
-  let notifyApplicationReadyPromise;
+  let notifyApplicationReadyPromise
   return () => {
     if (!notifyApplicationReadyPromise) {
-      notifyApplicationReadyPromise = notifyApplicationReadyInternal();
+      notifyApplicationReadyPromise = notifyApplicationReadyInternal()
     }
 
-    return notifyApplicationReadyPromise;
-  };
-})();
+    return notifyApplicationReadyPromise
+  }
+})()
 
 async function notifyApplicationReadyInternal() {
-  await NativeCodePush.notifyApplicationReady();
-  const statusReport = await NativeCodePush.getNewStatusReport();
-  statusReport && tryReportStatus(statusReport); // Don't wait for this to complete.
+  await NativeCodePush.notifyApplicationReady()
+  const statusReport = await NativeCodePush.getNewStatusReport()
+  statusReport && tryReportStatus(statusReport) // Don't wait for this to complete.
 
-  return statusReport;
+  return statusReport
 }
 
 async function tryReportStatus(statusReport, retryOnAppResume) {
-  const config = await getConfiguration();
+  const config = await getConfiguration()
 
   try {
     if (statusReport.appVersion) {
-      log(`Reporting binary update (${statusReport.appVersion})`);
+      log(`Reporting binary update (${statusReport.appVersion})`)
 
       if (!config.deploymentKey) {
-        throw new Error("Deployment key is missed");
+        throw new Error('Deployment key is missed')
       }
     } else {
-      const label = statusReport.package.label;
-      if (statusReport.status === "DeploymentSucceeded") {
-        log(`Reporting CodePush update success (${label})`);
+      const label = statusReport.package.label
+      if (statusReport.status === 'DeploymentSucceeded') {
+        log(`Reporting CodePush update success (${label})`)
       } else {
-        log(`Reporting CodePush update rollback (${label})`);
-        await NativeCodePush.setLatestRollbackInfo(statusReport.package.packageHash);
+        log(`Reporting CodePush update rollback (${label})`)
+        await NativeCodePush.setLatestRollbackInfo(
+          statusReport.package.packageHash
+        )
       }
     }
 
-    NativeCodePush.recordStatusReported(statusReport);
-    retryOnAppResume && retryOnAppResume.remove();
+    NativeCodePush.recordStatusReported(statusReport)
+    retryOnAppResume && retryOnAppResume.remove()
   } catch (e) {
-    log(`Report status failed: ${JSON.stringify(statusReport)}`);
-    NativeCodePush.saveStatusReportForRetry(statusReport);
+    log(`Report status failed: ${JSON.stringify(statusReport)}`)
+    NativeCodePush.saveStatusReportForRetry(statusReport)
     // Try again when the app resumes
     if (!retryOnAppResume) {
-      const resumeListener = AppState.addEventListener("change", async (newState) => {
-        if (newState !== "active") return;
-        const refreshedStatusReport = await NativeCodePush.getNewStatusReport();
-        if (refreshedStatusReport) {
-          tryReportStatus(refreshedStatusReport, resumeListener);
-        } else {
-          resumeListener && resumeListener.remove();
+      const resumeListener = AppState.addEventListener(
+        'change',
+        async (newState) => {
+          if (newState !== 'active') return
+          const refreshedStatusReport =
+            await NativeCodePush.getNewStatusReport()
+          if (refreshedStatusReport) {
+            tryReportStatus(refreshedStatusReport, resumeListener)
+          } else {
+            resumeListener && resumeListener.remove()
+          }
         }
-      });
+      )
     }
   }
 }
 
 async function shouldUpdateBeIgnored(remotePackage, syncOptions) {
-  let { rollbackRetryOptions } = syncOptions;
+  let { rollbackRetryOptions } = syncOptions
 
-  const isFailedPackage = remotePackage && remotePackage.failedInstall;
+  const isFailedPackage = remotePackage && remotePackage.failedInstall
   if (!isFailedPackage || !syncOptions.ignoreFailedUpdates) {
-    return false;
+    return false
   }
 
   if (!rollbackRetryOptions) {
-    return true;
+    return true
   }
 
-  if (typeof rollbackRetryOptions !== "object") {
-    rollbackRetryOptions = CodePush.DEFAULT_ROLLBACK_RETRY_OPTIONS;
+  if (typeof rollbackRetryOptions !== 'object') {
+    rollbackRetryOptions = CodePush.DEFAULT_ROLLBACK_RETRY_OPTIONS
   } else {
-    rollbackRetryOptions = { ...CodePush.DEFAULT_ROLLBACK_RETRY_OPTIONS, ...rollbackRetryOptions };
+    rollbackRetryOptions = {
+      ...CodePush.DEFAULT_ROLLBACK_RETRY_OPTIONS,
+      ...rollbackRetryOptions,
+    }
   }
 
   if (!validateRollbackRetryOptions(rollbackRetryOptions)) {
-    return true;
+    return true
   }
 
-  const latestRollbackInfo = await NativeCodePush.getLatestRollbackInfo();
-  if (!validateLatestRollbackInfo(latestRollbackInfo, remotePackage.packageHash)) {
-    log("The latest rollback info is not valid.");
-    return true;
+  const latestRollbackInfo = await NativeCodePush.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;
+  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;
+  return true
 }
 
 function validateLatestRollbackInfo(latestRollbackInfo, packageHash) {
-  return latestRollbackInfo &&
+  return (
+    latestRollbackInfo &&
     latestRollbackInfo.time &&
     latestRollbackInfo.count &&
     latestRollbackInfo.packageHash &&
-    latestRollbackInfo.packageHash === packageHash;
+    latestRollbackInfo.packageHash === packageHash
+  )
 }
 
 function validateRollbackRetryOptions(rollbackRetryOptions) {
-  if (typeof rollbackRetryOptions.delayInHours !== "number") {
-    log("The 'delayInHours' rollback retry parameter must be a number.");
-    return false;
+  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 (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;
+    log(
+      "The 'maxRetryAttempts' rollback retry parameter cannot be less then 1."
+    )
+    return false
   }
 
-  return true;
+  return true
 }
 
-let testConfig;
+let testConfig
 
 // This function is only used for tests. Replaces the default SDK, configuration and native bridge
 function setUpTestDependencies(testSdk, providedTestConfig, testNativeBridge) {
-  if (testSdk) module.exports.AcquisitionSdk = testSdk;
-  if (providedTestConfig) testConfig = providedTestConfig;
-  if (testNativeBridge) NativeCodePush = testNativeBridge;
+  if (testSdk) module.exports.AcquisitionSdk = testSdk
+  if (providedTestConfig) testConfig = providedTestConfig
+  if (testNativeBridge) NativeCodePush = testNativeBridge
 }
 
 async function restartApp(onlyIfUpdateIsPending = false) {
-  NativeCodePush.restartApp(onlyIfUpdateIsPending);
+  NativeCodePush.restartApp(onlyIfUpdateIsPending)
 }
 
 // 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.
 const sync = (() => {
-  let syncInProgress = false;
-  const setSyncCompleted = () => { syncInProgress = false; };
+  let syncInProgress = false
+  const setSyncCompleted = () => {
+    syncInProgress = false
+  }
 
-  return (options = {}, syncStatusChangeCallback, downloadProgressCallback, handleBinaryVersionMismatchCallback) => {
-    let syncStatusCallbackWithTryCatch, downloadProgressCallbackWithTryCatch;
-    if (typeof syncStatusChangeCallback === "function") {
+  return (
+    options = {},
+    syncStatusChangeCallback,
+    downloadProgressCallback,
+    handleBinaryVersionMismatchCallback
+  ) => {
+    let syncStatusCallbackWithTryCatch, downloadProgressCallbackWithTryCatch
+    if (typeof syncStatusChangeCallback === 'function') {
       syncStatusCallbackWithTryCatch = (...args) => {
         try {
-          syncStatusChangeCallback(...args);
+          syncStatusChangeCallback(...args)
         } catch (error) {
-          log(`An error has occurred : ${error.stack}`);
+          log(`An error has occurred : ${error.stack}`)
         }
       }
     }
 
-    if (typeof downloadProgressCallback === "function") {
+    if (typeof downloadProgressCallback === 'function') {
       downloadProgressCallbackWithTryCatch = (...args) => {
         try {
-          downloadProgressCallback(...args);
+          downloadProgressCallback(...args)
         } catch (error) {
-          log(`An error has occurred: ${error.stack}`);
+          log(`An error has occurred: ${error.stack}`)
         }
       }
     }
 
     if (syncInProgress) {
-      typeof syncStatusCallbackWithTryCatch === "function"
+      typeof syncStatusCallbackWithTryCatch === 'function'
         ? syncStatusCallbackWithTryCatch(CodePush.SyncStatus.SYNC_IN_PROGRESS)
-        : log("Sync already in progress.");
-      return Promise.resolve(CodePush.SyncStatus.SYNC_IN_PROGRESS);
+        : log('Sync already in progress.')
+      return Promise.resolve(CodePush.SyncStatus.SYNC_IN_PROGRESS)
     }
 
-    syncInProgress = true;
-    const syncPromise = syncInternal(options, syncStatusCallbackWithTryCatch, downloadProgressCallbackWithTryCatch, handleBinaryVersionMismatchCallback);
-    syncPromise
-      .then(setSyncCompleted)
-      .catch(setSyncCompleted);
+    syncInProgress = true
+    const syncPromise = syncInternal(
+      options,
+      syncStatusCallbackWithTryCatch,
+      downloadProgressCallbackWithTryCatch,
+      handleBinaryVersionMismatchCallback
+    )
+    syncPromise.then(setSyncCompleted).catch(setSyncCompleted)
 
-    return syncPromise;
-  };
-})();
+    return syncPromise
+  }
+})()
 
 /*
  * The syncInternal method provides a simple, one-line experience for
@@ -424,8 +491,13 @@ const sync = (() => {
  * releases, and displaying a standard confirmation UI to the end-user
  * when an update is available.
  */
-async function syncInternal(options = {}, syncStatusChangeCallback, downloadProgressCallback, handleBinaryVersionMismatchCallback) {
-  let resolvedInstallMode;
+async function syncInternal(
+  options = {},
+  syncStatusChangeCallback,
+  downloadProgressCallback,
+  handleBinaryVersionMismatchCallback
+) {
+  let resolvedInstallMode
   const syncOptions = {
     deploymentKey: null,
     ignoreFailedUpdates: true,
@@ -434,146 +506,178 @@ async function syncInternal(options = {}, syncStatusChangeCallback, downloadProg
     mandatoryInstallMode: CodePush.InstallMode.IMMEDIATE,
     minimumBackgroundDuration: 0,
     updateDialog: null,
-    ...options
-  };
-
-  syncStatusChangeCallback = typeof syncStatusChangeCallback === "function"
-    ? syncStatusChangeCallback
-    : (syncStatus) => {
-        switch(syncStatus) {
-          case CodePush.SyncStatus.CHECKING_FOR_UPDATE:
-            log("Checking for update.");
-            break;
-          case CodePush.SyncStatus.AWAITING_USER_ACTION:
-            log("Awaiting user action.");
-            break;
-          case CodePush.SyncStatus.DOWNLOADING_PACKAGE:
-            log("Downloading package.");
-            break;
-          case CodePush.SyncStatus.INSTALLING_UPDATE:
-            log("Installing update.");
-            break;
-          case CodePush.SyncStatus.UP_TO_DATE:
-            log("App is up to date.");
-            break;
-          case CodePush.SyncStatus.UPDATE_IGNORED:
-            log("User cancelled the update.");
-            break;
-          case CodePush.SyncStatus.UPDATE_INSTALLED:
-            if (resolvedInstallMode == CodePush.InstallMode.ON_NEXT_RESTART) {
-              log("Update is installed and will be run on the next app restart.");
-            } else if (resolvedInstallMode == CodePush.InstallMode.ON_NEXT_RESUME) {
-              if (syncOptions.minimumBackgroundDuration > 0) {
-                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.");
+    ...options,
+  }
+
+  syncStatusChangeCallback =
+    typeof syncStatusChangeCallback === 'function'
+      ? syncStatusChangeCallback
+      : (syncStatus) => {
+          switch (syncStatus) {
+            case CodePush.SyncStatus.CHECKING_FOR_UPDATE:
+              log('Checking for update.')
+              break
+            case CodePush.SyncStatus.AWAITING_USER_ACTION:
+              log('Awaiting user action.')
+              break
+            case CodePush.SyncStatus.DOWNLOADING_PACKAGE:
+              log('Downloading package.')
+              break
+            case CodePush.SyncStatus.INSTALLING_UPDATE:
+              log('Installing update.')
+              break
+            case CodePush.SyncStatus.UP_TO_DATE:
+              log('App is up to date.')
+              break
+            case CodePush.SyncStatus.UPDATE_IGNORED:
+              log('User cancelled the update.')
+              break
+            case CodePush.SyncStatus.UPDATE_INSTALLED:
+              if (resolvedInstallMode == CodePush.InstallMode.ON_NEXT_RESTART) {
+                log(
+                  'Update is installed and will be run on the next app restart.'
+                )
+              } else if (
+                resolvedInstallMode == CodePush.InstallMode.ON_NEXT_RESUME
+              ) {
+                if (syncOptions.minimumBackgroundDuration > 0) {
+                  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 CodePush.SyncStatus.UNKNOWN_ERROR:
-            log("An unknown error occurred.");
-            break;
+              break
+            case CodePush.SyncStatus.UNKNOWN_ERROR:
+              log('An unknown error occurred.')
+              break
+          }
         }
-      };
 
   try {
-    await CodePush.notifyApplicationReady();
+    await CodePush.notifyApplicationReady()
 
-    syncStatusChangeCallback(CodePush.SyncStatus.CHECKING_FOR_UPDATE);
-    const remotePackage = await checkForUpdate(syncOptions.deploymentKey, handleBinaryVersionMismatchCallback);
+    syncStatusChangeCallback(CodePush.SyncStatus.CHECKING_FOR_UPDATE)
+    const remotePackage = await checkForUpdate(
+      syncOptions.deploymentKey,
+      handleBinaryVersionMismatchCallback
+    )
 
     const doDownloadAndInstall = async () => {
-      syncStatusChangeCallback(CodePush.SyncStatus.DOWNLOADING_PACKAGE);
-      const localPackage = await remotePackage.download(downloadProgressCallback);
+      syncStatusChangeCallback(CodePush.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(CodePush.SyncStatus.INSTALLING_UPDATE);
-      await localPackage.install(resolvedInstallMode, syncOptions.minimumBackgroundDuration, () => {
-        syncStatusChangeCallback(CodePush.SyncStatus.UPDATE_INSTALLED);
-      });
+      resolvedInstallMode = localPackage.isMandatory
+        ? syncOptions.mandatoryInstallMode
+        : syncOptions.installMode
+
+      syncStatusChangeCallback(CodePush.SyncStatus.INSTALLING_UPDATE)
+      await localPackage.install(
+        resolvedInstallMode,
+        syncOptions.minimumBackgroundDuration,
+        () => {
+          syncStatusChangeCallback(CodePush.SyncStatus.UPDATE_INSTALLED)
+        }
+      )
 
-      return CodePush.SyncStatus.UPDATE_INSTALLED;
-    };
+      return CodePush.SyncStatus.UPDATE_INSTALLED
+    }
 
-    const updateShouldBeIgnored = await shouldUpdateBeIgnored(remotePackage, syncOptions);
+    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.");
+        log(
+          'An update is available, but it is being ignored due to having been previously rolled back.'
+        )
       }
 
-      const currentPackage = await CodePush.getCurrentPackage();
+      const currentPackage = await CodePush.getCurrentPackage()
       if (currentPackage && currentPackage.isPending) {
-        syncStatusChangeCallback(CodePush.SyncStatus.UPDATE_INSTALLED);
-        return CodePush.SyncStatus.UPDATE_INSTALLED;
+        syncStatusChangeCallback(CodePush.SyncStatus.UPDATE_INSTALLED)
+        return CodePush.SyncStatus.UPDATE_INSTALLED
       } else {
-        syncStatusChangeCallback(CodePush.SyncStatus.UP_TO_DATE);
-        return CodePush.SyncStatus.UP_TO_DATE;
+        syncStatusChangeCallback(CodePush.SyncStatus.UP_TO_DATE)
+        return CodePush.SyncStatus.UP_TO_DATE
       }
     } else if (syncOptions.updateDialog) {
       // updateDialog supports any truthy value (e.g. true, "goo", 12),
       // but we should treat a non-object value as just the default dialog
-      if (typeof syncOptions.updateDialog !== "object") {
-        syncOptions.updateDialog = CodePush.DEFAULT_UPDATE_DIALOG;
+      if (typeof syncOptions.updateDialog !== 'object') {
+        syncOptions.updateDialog = CodePush.DEFAULT_UPDATE_DIALOG
       } else {
-        syncOptions.updateDialog = { ...CodePush.DEFAULT_UPDATE_DIALOG, ...syncOptions.updateDialog };
+        syncOptions.updateDialog = {
+          ...CodePush.DEFAULT_UPDATE_DIALOG,
+          ...syncOptions.updateDialog,
+        }
       }
 
       return await new Promise((resolve, reject) => {
-        let message = null;
-        let installButtonText = null;
+        let message = null
+        let installButtonText = null
 
-        const dialogButtons = [];
+        const dialogButtons = []
 
         if (remotePackage.isMandatory) {
-          message = syncOptions.updateDialog.mandatoryUpdateMessage;
-          installButtonText = syncOptions.updateDialog.mandatoryContinueButtonLabel;
+          message = syncOptions.updateDialog.mandatoryUpdateMessage
+          installButtonText =
+            syncOptions.updateDialog.mandatoryContinueButtonLabel
         } else {
-          message = syncOptions.updateDialog.optionalUpdateMessage;
-          installButtonText = syncOptions.updateDialog.optionalInstallButtonLabel;
+          message = syncOptions.updateDialog.optionalUpdateMessage
+          installButtonText =
+            syncOptions.updateDialog.optionalInstallButtonLabel
           // Since this is an optional update, add a button
           // to allow the end-user to ignore it
           dialogButtons.push({
             text: syncOptions.updateDialog.optionalIgnoreButtonLabel,
             onPress: () => {
-              syncStatusChangeCallback(CodePush.SyncStatus.UPDATE_IGNORED);
-              resolve(CodePush.SyncStatus.UPDATE_IGNORED);
-            }
-          });
+              syncStatusChangeCallback(CodePush.SyncStatus.UPDATE_IGNORED)
+              resolve(CodePush.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);
-          }
+          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 (syncOptions.updateDialog.appendReleaseDescription && remotePackage.description) {
-          message += `${syncOptions.updateDialog.descriptionPrefix} ${remotePackage.description}`;
+        if (
+          syncOptions.updateDialog.appendReleaseDescription &&
+          remotePackage.description
+        ) {
+          message += `${syncOptions.updateDialog.descriptionPrefix} ${remotePackage.description}`
         }
 
-        syncStatusChangeCallback(CodePush.SyncStatus.AWAITING_USER_ACTION);
-        Alert.alert(syncOptions.updateDialog.title, message, dialogButtons);
-      });
+        syncStatusChangeCallback(CodePush.SyncStatus.AWAITING_USER_ACTION)
+        Alert.alert(syncOptions.updateDialog.title, message, dialogButtons)
+      })
     } else {
-      return await doDownloadAndInstall();
+      return await doDownloadAndInstall()
     }
   } catch (error) {
-    syncStatusChangeCallback(CodePush.SyncStatus.UNKNOWN_ERROR);
-    log(error.message);
-    throw error;
+    syncStatusChangeCallback(CodePush.SyncStatus.UNKNOWN_ERROR)
+    log(error.message)
+    throw error
   }
-};
+}
 
-let CodePush;
+let CodePush
 
 /**
  * @callback releaseHistoryFetcher
@@ -601,105 +705,145 @@ let CodePush;
 const sharedCodePushOptions = {
   releaseHistoryFetcher: undefined,
   setReleaseHistoryFetcher(releaseHistoryFetcherFunction) {
-    if (!releaseHistoryFetcherFunction || typeof releaseHistoryFetcherFunction !== 'function') throw new Error('Please implement the releaseHistoryFetcher function');
-    this.releaseHistoryFetcher = releaseHistoryFetcherFunction;
+    if (
+      !releaseHistoryFetcherFunction ||
+      typeof releaseHistoryFetcherFunction !== 'function'
+    )
+      throw new Error('Please implement the releaseHistoryFetcher function')
+    this.releaseHistoryFetcher = releaseHistoryFetcherFunction
   },
   updateChecker: undefined,
   setUpdateChecker(updateCheckerFunction) {
-    if (!updateCheckerFunction) return;
-    if (typeof updateCheckerFunction !== 'function') throw new Error('Please pass a function to updateChecker');
-    this.updateChecker = updateCheckerFunction;
+    if (!updateCheckerFunction) return
+    if (typeof updateCheckerFunction !== 'function')
+      throw new Error('Please pass a function to updateChecker')
+    this.updateChecker = updateCheckerFunction
   },
 }
 
 function codePushify(options = {}) {
-  let React;
-  let ReactNative = require("react-native");
+  let React
+  let ReactNative = require('react-native')
 
-  try { React = require("react"); } catch (e) { }
+  try {
+    React = require('react')
+  } catch (e) {}
   if (!React) {
-    try { React = ReactNative.React; } catch (e) { }
+    try {
+      React = ReactNative.React
+    } catch (e) {}
     if (!React) {
-      throw new Error("Unable to find the 'React' module.");
+      throw new Error("Unable to find the 'React' module.")
     }
   }
 
   if (!React.Component) {
     throw new Error(
-`Unable to find the "Component" class, please either:
+      `Unable to find the "Component" class, please either:
 1. Upgrade to a newer version of React Native that supports it, or
 2. Call the codePush.sync API in your component instead of using the @codePush decorator`
-    );
+    )
   }
 
   if (options.updateChecker && !options.releaseHistoryFetcher) {
-    throw new Error('If you want to use `updateChecker`, pass a no-op function to releaseHistoryFetcher option. (e.g. `releaseHistoryFetcher: async () => ({})`)');
+    throw new Error(
+      'If you want to use `updateChecker`, pass a no-op function to releaseHistoryFetcher option. (e.g. `releaseHistoryFetcher: async () => ({})`)'
+    )
   }
 
-  sharedCodePushOptions.setReleaseHistoryFetcher(options.releaseHistoryFetcher);
-  sharedCodePushOptions.setUpdateChecker(options.updateChecker);
+  sharedCodePushOptions.setReleaseHistoryFetcher(options.releaseHistoryFetcher)
+  sharedCodePushOptions.setUpdateChecker(options.updateChecker)
 
   const decorator = (RootComponent) => {
     class CodePushComponent extends React.Component {
       constructor(props) {
-        super(props);
-        this.rootComponentRef = React.createRef();
+        super(props)
+        this.rootComponentRef = React.createRef()
       }
 
       componentDidMount() {
         if (options.checkFrequency === CodePush.CheckFrequency.MANUAL) {
-          CodePush.notifyAppReady();
+          CodePush.notifyAppReady()
         } else {
-          const rootComponentInstance = this.rootComponentRef.current;
-
-          let syncStatusCallback;
-          if (rootComponentInstance && rootComponentInstance.codePushStatusDidChange) {
-            syncStatusCallback = rootComponentInstance.codePushStatusDidChange.bind(rootComponentInstance);
+          const rootComponentInstance = this.rootComponentRef.current
+
+          let syncStatusCallback
+          if (
+            rootComponentInstance &&
+            rootComponentInstance.codePushStatusDidChange
+          ) {
+            syncStatusCallback =
+              rootComponentInstance.codePushStatusDidChange.bind(
+                rootComponentInstance
+              )
           }
 
-          let downloadProgressCallback;
-          if (rootComponentInstance && rootComponentInstance.codePushDownloadDidProgress) {
-            downloadProgressCallback = rootComponentInstance.codePushDownloadDidProgress.bind(rootComponentInstance);
+          let downloadProgressCallback
+          if (
+            rootComponentInstance &&
+            rootComponentInstance.codePushDownloadDidProgress
+          ) {
+            downloadProgressCallback =
+              rootComponentInstance.codePushDownloadDidProgress.bind(
+                rootComponentInstance
+              )
           }
 
-          let handleBinaryVersionMismatchCallback;
-          if (rootComponentInstance && rootComponentInstance.codePushOnBinaryVersionMismatch) {
-            handleBinaryVersionMismatchCallback = rootComponentInstance.codePushOnBinaryVersionMismatch.bind(rootComponentInstance);
+          let handleBinaryVersionMismatchCallback
+          if (
+            rootComponentInstance &&
+            rootComponentInstance.codePushOnBinaryVersionMismatch
+          ) {
+            handleBinaryVersionMismatchCallback =
+              rootComponentInstance.codePushOnBinaryVersionMismatch.bind(
+                rootComponentInstance
+              )
           }
 
-          CodePush.sync(options, syncStatusCallback, downloadProgressCallback, handleBinaryVersionMismatchCallback);
-
-          if (options.checkFrequency === CodePush.CheckFrequency.ON_APP_RESUME) {
-            ReactNative.AppState.addEventListener("change", (newState) => {
-              if (newState === "active") {
-                CodePush.sync(options, syncStatusCallback, downloadProgressCallback);
+          CodePush.sync(
+            options,
+            syncStatusCallback,
+            downloadProgressCallback,
+            handleBinaryVersionMismatchCallback
+          )
+
+          if (
+            options.checkFrequency === CodePush.CheckFrequency.ON_APP_RESUME
+          ) {
+            ReactNative.AppState.addEventListener('change', (newState) => {
+              if (newState === 'active') {
+                CodePush.sync(
+                  options,
+                  syncStatusCallback,
+                  downloadProgressCallback
+                )
               }
-            });
+            })
           }
         }
       }
 
       render() {
-        const props = {...this.props};
+        const props = { ...this.props }
 
         // We can set ref property on class components only (not stateless)
         // Check it by render method
         if (RootComponent.prototype && RootComponent.prototype.render) {
-          props.ref = this.rootComponentRef;
+          props.ref = this.rootComponentRef
         }
 
         return <RootComponent {...props} />
       }
     }
 
-    return hoistStatics(CodePushComponent, RootComponent);
+    return hoistStatics(CodePushComponent, RootComponent)
   }
 
-  if (typeof options === "function") {
+  if (typeof options === 'function') {
     // Infer that the root component was directly passed to us.
-    return decorator(options);
+    return decorator(options)
   } else {
-    return decorator;
+    return decorator
   }
 }
 
@@ -708,7 +852,7 @@ function codePushify(options = {}) {
 // and therefore, it doesn't make sense initializing
 // the JS interface when it wouldn't work anyways.
 if (NativeCodePush) {
-  CodePush = codePushify;
+  CodePush = codePushify
   Object.assign(CodePush, {
     checkForUpdate,
     getConfiguration,
@@ -727,7 +871,7 @@ if (NativeCodePush) {
       IMMEDIATE: NativeCodePush.codePushInstallModeImmediate, // Restart the app immediately
       ON_NEXT_RESTART: NativeCodePush.codePushInstallModeOnNextRestart, // Don't artificially restart the app. Allow the update to be "picked up" on the next app restart
       ON_NEXT_RESUME: NativeCodePush.codePushInstallModeOnNextResume, // Restart the app the next time it is resumed from the background
-      ON_NEXT_SUSPEND: NativeCodePush.codePushInstallModeOnNextSuspend // Restart the app _while_ it is in the background,
+      ON_NEXT_SUSPEND: NativeCodePush.codePushInstallModeOnNextSuspend, // Restart the app _while_ it is in the background,
       // but only after it has been in the background for "minimumBackgroundDuration" seconds (0 by default),
       // so that user context isn't lost unless the app suspension is long enough to not matter
     },
@@ -740,39 +884,42 @@ if (NativeCodePush) {
       CHECKING_FOR_UPDATE: 5,
       AWAITING_USER_ACTION: 6,
       DOWNLOADING_PACKAGE: 7,
-      INSTALLING_UPDATE: 8
+      INSTALLING_UPDATE: 8,
     },
     CheckFrequency: {
       ON_APP_START: 0,
       ON_APP_RESUME: 1,
-      MANUAL: 2
+      MANUAL: 2,
     },
     UpdateState: {
       RUNNING: NativeCodePush.codePushUpdateStateRunning,
       PENDING: NativeCodePush.codePushUpdateStatePending,
-      LATEST: NativeCodePush.codePushUpdateStateLatest
+      LATEST: NativeCodePush.codePushUpdateStateLatest,
     },
     DeploymentStatus: {
-      FAILED: "DeploymentFailed",
-      SUCCEEDED: "DeploymentSucceeded",
+      FAILED: 'DeploymentFailed',
+      SUCCEEDED: 'DeploymentSucceeded',
     },
     DEFAULT_UPDATE_DIALOG: {
       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"
+      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',
     },
     DEFAULT_ROLLBACK_RETRY_OPTIONS: {
       delayInHours: 24,
-      maxRetryAttempts: 1
+      maxRetryAttempts: 1,
     },
-  });
+  })
 } else {
-  log("The CodePush module doesn't appear to be properly installed. Please double-check that everything is setup correctly.");
+  log(
+    "The CodePush module doesn't appear to be properly installed. Please double-check that everything is setup correctly."
+  )
 }
 
-module.exports = CodePush;
+module.exports = CodePush

package/cli/commands/common.js

@@ -33,7 +33,7 @@ async function getIdentifierValue() {
       type: 'list',
       name: 'identifier',
       message: 'Select the target env identifier',
-      choices: ['stg', 'prd'],
+      choices: ['dev', 'stg', 'prd'],
     },
   ])
   return identifier

package/cli/commands/createPullRequestHistoryCommand/createPullRequestHistory.js

@@ -3,12 +3,12 @@ const path = require('path')
 
 async function createPullRequestHistory(
   setReleaseHistory,
-  prNumber,
+  binaryVersion,
   app,
   platform
 ) {
   try {
-    const JSON_FILE_NAME = `${prNumber}.json`
+    const JSON_FILE_NAME = `${binaryVersion}.json`
     const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME)
 
     console.log(
@@ -17,7 +17,7 @@ async function createPullRequestHistory(
     )
     fs.writeFileSync(JSON_FILE_PATH, JSON.stringify({}))
 
-    await setReleaseHistory(prNumber, JSON_FILE_PATH, {}, app, platform)
+    await setReleaseHistory(binaryVersion, JSON_FILE_PATH, {}, app, platform)
 
     fs.unlinkSync(JSON_FILE_PATH)
   } catch (error) {

package/cli/commands/createPullRequestHistoryCommand/index.js

@@ -8,7 +8,6 @@ program
   .description('Creates a new pull request history.')
   .option('-a, --app <string>', 'target app (user/device)')
   .option('-p, --platform <string>', 'target platform (ios/android)')
-  .option('-r, --pr-number <number>', 'pull request number')
   .option(
     '-c, --config <path>',
     'set config file name (JS/TS)',
@@ -22,7 +21,7 @@ program
 
     await createPullRequestHistory(
       setReleaseHistory,
-      options.prNumber,
+      options.binaryVersion,
       options.app,
       options.platform
     )

package/cli/commands/createPullRequestReleaseCommand/addToPullRequestRelease.js

@@ -13,12 +13,17 @@ async function addToPullRequestRelease(
   setReleaseHistory,
   getReleaseHistory
 ) {
-  const releaseHistory = await getReleaseHistory(app, prNumber, platform)
-  const latestReleaseHistoryNumber = Object.keys(releaseHistory).at(-1)
+  const releaseHistory = await getReleaseHistory(app, binaryVersion, platform)
 
-  const newReleaseHistoryNumber = latestReleaseHistoryNumber
-    ? `${Number(latestReleaseHistoryNumber[0]) + 1}.0.0`
-    : '1.0.0'
+  const latestReleaseHistoryKeys = Object.keys(releaseHistory)
+  const releaseHistoryWithPRNumber = latestReleaseHistoryKeys.filter((key) =>
+    key.includes(prNumber)
+  )
+
+  const newReleaseHistoryNumber = getNewReleaseHistoryNumber(
+    releaseHistoryWithPRNumber,
+    prNumber
+  )
   const newReleaseHistory = structuredClone(releaseHistory)
 
   newReleaseHistory[newReleaseHistoryNumber] = {
@@ -30,7 +35,7 @@ async function addToPullRequestRelease(
   }
 
   try {
-    const JSON_FILE_NAME = `${prNumber}.json`
+    const JSON_FILE_NAME = `${binaryVersion}.json`
     const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME)
 
     console.log(
@@ -40,12 +45,13 @@ async function addToPullRequestRelease(
     fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(newReleaseHistory))
 
     await setReleaseHistory(
-      prNumber,
+      binaryVersion,
       JSON_FILE_PATH,
       newReleaseHistory,
       app,
       platform
     )
+    process.stdout.write(packageHash)
   } catch (error) {
     console.error('Error occurred while updating history:', error)
     process.exit(1)
@@ -55,3 +61,13 @@ async function addToPullRequestRelease(
 module.exports = {
   addToPullRequestRelease,
 }
+
+function getNewReleaseHistoryNumber(releaseHistoryWithPRNumber, prNumber) {
+  if (releaseHistoryWithPRNumber.length) {
+    const [, latestVersion] = releaseHistoryWithPRNumber.at(-1).split('-')
+    const newVersion = `${prNumber}-${Number(latestVersion[0]) + 1}.0.0`
+    return newVersion
+  } else {
+    return `${prNumber}-1.0.0`
+  }
+}

package/cli/commands/releaseCommand/index.js

@@ -22,7 +22,7 @@ program
   )
   .option('-a, --app <string>', 'target app (user/device)')
   .option('-p, --platform <string>', 'target platform (ios/android)')
-  .option('-i, --identifier <string>', 'target env identifier (stg/prd)')
+  .option('-i, --identifier <string>', 'target env identifier (dev/stg/prd)')
   .option('-b, --binary-version <string>', 'target binary version (x.y.z)')
   .option('-v, --app-version <string>', 'target codepush version (x.y.z)')
   .option(
@@ -67,8 +67,11 @@ program
       throw new Error('Device app is not supported on iOS')
     }
 
-    if (options.identifier && !['stg', 'prd'].includes(options.identifier)) {
-      throw new Error('Identifier must be either "stg" or "prd"')
+    if (
+      options.identifier &&
+      !['dev', 'stg', 'prd'].includes(options.identifier)
+    ) {
+      throw new Error('Identifier must be either "dev" or "stg" or "prd"')
     }
 
     const semverRegex = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/

package/cli/index.js

@@ -55,9 +55,4 @@ require('./commands/createPullRequestReleaseCommand')
  */
 require('./commands/removePullRequestHistoryCommand')
 
-/**
- * npx code-push get-development-key
- */
-require('./commands/getDevelopmentKeyCommand')
-
 program.parse()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algocare/react-native-code-push",
-  "version": "10.3.2",
+  "version": "11.0.0",
   "description": "React Native plugin for the CodePush service",
   "main": "CodePush.js",
   "typings": "typings/react-native-code-push.d.ts",

package/cli/commands/getDevelopmentKeyCommand/index.js

@@ -1,31 +0,0 @@
-const { program } = require('commander')
-const { findAndReadConfigFile } = require('../../utils/fsUtils')
-const { COMPILED_CONFIG_FILE_NAME } = require('../../constant')
-
-program
-  .command('get-development-key')
-  .description('the development key for a specific app and platform.')
-  .option('-a, --app <string>', 'target app (user/device)')
-  .option('-p, --platform <string>', 'target platform (ios/android)')
-  .option('-b, --binary-version <string>', 'target binary version (x.y.z)')
-  .option('-r, --pr-number <number>', 'pull request number')
-  .option(
-    '-c, --config <path>',
-    'configuration file name (JS/TS)',
-    COMPILED_CONFIG_FILE_NAME
-  )
-  .action(async (options) => {
-    const { getReleaseHistory } = await findAndReadConfigFile(
-      process.cwd(),
-      options.config
-    )
-
-    const releaseHistory = await getReleaseHistory(
-      options.app,
-      options.binaryVersion || options.prNumber,
-      options.platform
-    )
-
-    const latestReleaseVersion = Object.keys(releaseHistory).at(-1)
-    process.stdout.write(releaseHistory[latestReleaseVersion].packageHash)
-  })