@appzung/react-native-code-push 11.0.0-rc1 → 11.0.0-rc10

package/src/enums/InstallMode.enum.ts

@@ -6,18 +6,22 @@ import { NativeRNAppZungCodePushModule } from '../internals/NativeRNAppZungCodeP
 export enum InstallMode {
   /**
    * Indicates that you want to install the update and restart the app immediately.
+   *
+   * This value is appropriate for debugging scenarios as well as when displaying an update prompt to the user, since they would expect to see the changes immediately after accepting the installation. Additionally, this mode can be used to enforce mandatory updates, since it removes the potentially undesired latency between the update installation and the next time the end user restarts or resumes the app.
    */
   IMMEDIATE = NativeRNAppZungCodePushModule.getConstants().codePushInstallModeImmediate,
 
   /**
    * Indicates that you want to install the update, but not forcibly restart the app.
+   *
+   * When the app is "naturally" restarted (due the OS or end user killing it), the update will be seamlessly picked up. This value is appropriate when performing silent updates, since it would likely be disruptive to the end user if the app suddenly restarted out of nowhere, since they wouldn't have realized an update was even downloaded. This is the default mode used for both the `sync` and `LocalPackage.install` methods.
    */
   ON_NEXT_RESTART = NativeRNAppZungCodePushModule.getConstants().codePushInstallModeOnNextRestart,
 
   /**
-   * Indicates that you want to install the update, but don't want to restart the app until the next time
-   * the end user resumes it from the background. This way, you don't disrupt their current session,
-   * but you can get the update in front of them sooner than having to wait for the next natural restart.
+   * Indicates that you want to install the update, but don't want to restart the app until the next time the end user resumes it from the background.
+   *
+   * This way, you don't disrupt their current session,but you can get the update in front of them sooner than having to wait for the next natural restart.
    * This value is appropriate for silent installs that can be applied on resume in a non-invasive way.
    */
   ON_NEXT_RESUME = NativeRNAppZungCodePushModule.getConstants().codePushInstallModeOnNextResume,

package/src/enums/LogLevel.enum.ts

@@ -0,0 +1,9 @@
+/**
+ * Used to categorize log messages by their severity and importance.
+ */
+export enum LogLevel {
+  DEBUG,
+  INFO,
+  WARN,
+  ERROR,
+}

package/src/enums/SyncStatus.enum.ts

@@ -3,30 +3,30 @@
  */
 export enum SyncStatus {
   /**
-   * The app is up-to-date with the CodePush server.
+   * The app is fully up-to-date with the configured release channel.
    */
   UP_TO_DATE,
 
   /**
    * An available update has been installed and will be run either immediately after the
-   * syncStatusChangedCallback function returns or the next time the app resumes/restarts,
-   * depending on the InstallMode specified in SyncOptions
+   * `syncStatusChangedCallback` function returns or the next time the app resumes/restarts,
+   * depending on the `InstallMode` specified in `SyncOptions`
    */
   UPDATE_INSTALLED,
 
   /**
    * The app had an optional update which the end user chose to ignore.
-   * (This is only applicable when the updateDialog is used)
+   * (This is only applicable when the `updateDialog` is used)
    */
   UPDATE_IGNORED,
 
   /**
-   * The sync operation encountered an unknown error.
+   * The `sync` operation encountered an unknown error.
    */
   UNKNOWN_ERROR,
 
   /**
-   * There is an ongoing sync operation running which prevents the current call from being executed.
+   * There is an ongoing `sync` operation running which prevents the current call from being executed.
    */
   SYNC_IN_PROGRESS,
 
@@ -37,7 +37,7 @@ export enum SyncStatus {
 
   /**
    * An update is available, and a confirmation dialog was shown
-   * to the end user. (This is only applicable when the updateDialog is used)
+   * to the end user. (This is only applicable when the `updateDialog` is used)
    */
   AWAITING_USER_ACTION,
 

package/src/enums/UpdateState.enum.ts

@@ -5,20 +5,21 @@ import { NativeRNAppZungCodePushModule } from '../internals/NativeRNAppZungCodeP
  */
 export enum UpdateState {
   /**
-   * Indicates that an update represents the
-   * version of the app that is currently running.
+   * Indicates that an update represents the version of the app that is currently running.
+   *
+   * This can be useful for identifying attributes about the app, for scenarios such as displaying the release description in a "what's new?" dialog or reporting the latest version to an analytics and/or crash reporting service.
    */
   RUNNING = NativeRNAppZungCodePushModule.getConstants().codePushUpdateStateRunning,
 
   /**
-   * Indicates than an update has been installed, but the
-   * app hasn't been restarted yet in order to apply it.
+   * Indicates than an update has been installed, but the app hasn't been restarted yet in order to apply it.
+   *
+   * This can be useful for determining whether there is a pending update, which you may want to force a programmatic restart (via `restartApp`) in order to apply.
    */
   PENDING = NativeRNAppZungCodePushModule.getConstants().codePushUpdateStatePending,
 
   /**
-   * Indicates than an update represents the latest available
-   * release, and can be either currently running or pending.
+   * Indicates than an update represents the latest available release, and can be either currently running or pending.
    */
   LATEST = NativeRNAppZungCodePushModule.getConstants().codePushUpdateStateLatest,
 }

package/src/getClientUniqueId.ts

@@ -0,0 +1,9 @@
+import { getConfiguration } from './internals/getConfiguration';
+
+/**
+ * Gets the client's unique ID set by the module. You may also see `resetClientUniqueId`.
+ */
+export const getClientUniqueId = async () => {
+  const nativeConfig = await getConfiguration();
+  return nativeConfig.clientUniqueId;
+};

package/src/index.ts

@@ -8,11 +8,18 @@ export * from './getUpdateMetadata';
 export * from './notifyAppReady';
 export * from './restartApp';
 export * from './sync';
+export * from './getClientUniqueId';
+export * from './resetClientUniqueId';
+export * from './logLevel';
+export * from './logger';
+export * from './telemetry';
+export * from './dataTransmission';
 
 export * from './types';
 
 export * from './enums/SyncStatus.enum';
 export * from './enums/InstallMode.enum';
 export * from './enums/UpdateState.enum';
-export * from './enums/DeploymentStatus.enum';
+export { DeploymentStatus } from './internals/CodePushApiSdk.types';
 export * from './enums/CheckFrequency.enum';
+export * from './enums/LogLevel.enum';

package/src/internals/CodePushApiSdk.errors.ts

@@ -0,0 +1,22 @@
+export class CodePushError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'CodePushError';
+  }
+}
+
+export class CodePushHttpError extends CodePushError {
+  constructor(
+    readonly url: string,
+    readonly statusCode: number,
+    message: string,
+  ) {
+    super(message);
+
+    if (statusCode === 0) {
+      this.message = `Couldn't send request to ${url}, xhr.statusCode = 0 was returned. One of the possible reasons for that might be connection problems. Please, check your internet connection.`;
+    }
+
+    this.name = 'CodePushHttpError';
+  }
+}

package/src/internals/CodePushApiSdk.ts

@@ -0,0 +1,160 @@
+import { LogLevel } from '../enums/LogLevel.enum';
+import { CodePushError, CodePushHttpError } from './CodePushApiSdk.errors';
+import {
+  type ApiSdkConfiguration,
+  type ApiSdkDeployReportPackageInfo,
+  type ApiSdkDownloadReportPackageInfo,
+  type ApiSdkNativeUpdateNotification,
+  type ApiSdkQueryUpdatePackageInfo,
+  type ApiSdkRemotePackage,
+  type CheckUpdateRequestInput,
+  type CheckUpdateResponse,
+  DeploymentStatus,
+  type Http,
+  type ReportDeployInput,
+  type ReportDownloadInput,
+} from './CodePushApiSdk.types';
+import { queryStringify } from './utils/queryStringify';
+
+// TODO move this to @appzung/code-push-api-sdk
+
+export class CodePushApiSdk {
+  private configuration: ApiSdkConfiguration;
+
+  constructor(
+    private readonly httpRequester: Http.Requester,
+    private readonly log: (level: LogLevel, message: string) => void,
+    configuration: ApiSdkConfiguration,
+  ) {
+    this.configuration = { ...configuration };
+    if (this.configuration.serverUrl.slice(-1) !== '/') {
+      this.configuration.serverUrl += '/';
+    }
+    this.configuration.serverUrl += 'v0.1/public/codepush';
+  }
+
+  async queryUpdateWithCurrentPackage(
+    currentPackageInfo: ApiSdkQueryUpdatePackageInfo,
+  ): Promise<ApiSdkRemotePackage | ApiSdkNativeUpdateNotification | null> {
+    if (!this.configuration.dataTransmissionEnabled) {
+      this.log(LogLevel.DEBUG, 'Skipped querying for update because data transmission is disabled');
+      return null;
+    }
+
+    const query: CheckUpdateRequestInput = {
+      deployment_key: this.configuration.releaseChannelPublicId,
+      app_version: currentPackageInfo.appVersion,
+      package_hash: currentPackageInfo.packageHash,
+      is_companion: this.configuration.ignoreAppVersion,
+      label: currentPackageInfo.label,
+      client_unique_id: this.configuration.clientUniqueId,
+    };
+
+    const url = `${this.configuration.serverUrl}/update_check?${queryStringify(query)}`;
+
+    const response = await this.httpRequester.request('GET', url);
+
+    if (response.statusCode < 200 || response.statusCode >= 300) {
+      throw new CodePushHttpError(url, response.statusCode, response.body || 'No body');
+    }
+
+    const responseObject: CheckUpdateResponse | Record<string, never> = JSON.parse(response.body || '{}');
+    if (!responseObject.update_info) {
+      throw new CodePushError('Missing update info in response');
+    }
+
+    const { update_info: updateInfo } = responseObject;
+
+    if (updateInfo.update_app_version) {
+      return {
+        updateAppVersion: true,
+        appVersion: responseObject.update_info.target_binary_range,
+      };
+    }
+
+    if (!updateInfo.is_available) {
+      return null;
+    }
+
+    return {
+      releaseChannelPublicId: this.configuration.releaseChannelPublicId,
+      description: updateInfo.description,
+      label: updateInfo.label,
+      appVersion: updateInfo.target_binary_range,
+      isMandatory: updateInfo.is_mandatory,
+      packageHash: updateInfo.package_hash,
+      packageSize: updateInfo.package_size,
+      downloadUrl: updateInfo.download_url,
+    };
+  }
+
+  async reportStatusDeploy(
+    deployedPackageInfo: { package: ApiSdkDeployReportPackageInfo; status: DeploymentStatus } | null,
+    previousLabelOrAppVersion: string | null,
+    previousDeploymentKey: string | null,
+  ): Promise<void> {
+    if (!this.configuration.dataTransmissionEnabled) {
+      this.log(LogLevel.DEBUG, 'Skipped reporting deploy status because data transmission is disabled');
+      return;
+    }
+
+    if (!this.configuration.telemetryEnabled) {
+      this.log(LogLevel.DEBUG, 'Skipped reporting deploy status because telemetry is disabled');
+      return;
+    }
+
+    const requestBody: ReportDeployInput = {
+      app_version: this.configuration.appVersion,
+      deployment_key: this.configuration.releaseChannelPublicId,
+      client_unique_id: this.configuration.clientUniqueId,
+    };
+
+    if (deployedPackageInfo) {
+      requestBody.label = deployedPackageInfo.package.label;
+      requestBody.app_version = deployedPackageInfo.package.appVersion;
+      requestBody.status = deployedPackageInfo.status;
+    }
+
+    if (previousLabelOrAppVersion) {
+      requestBody.previous_label_or_app_version = previousLabelOrAppVersion;
+    }
+
+    if (previousDeploymentKey) {
+      requestBody.previous_deployment_key = previousDeploymentKey;
+    }
+
+    const url = `${this.configuration.serverUrl}/report_status/deploy`;
+
+    const response = await this.httpRequester.request('POST', url, JSON.stringify(requestBody));
+
+    if (response.statusCode < 200 || response.statusCode >= 300) {
+      throw new CodePushHttpError(url, response.statusCode, response.body || 'No body');
+    }
+  }
+
+  async reportStatusDownload(downloadedPackage: ApiSdkDownloadReportPackageInfo): Promise<void> {
+    if (!this.configuration.dataTransmissionEnabled) {
+      this.log(LogLevel.DEBUG, 'Skipped reporting download because data transmission is disabled');
+      return;
+    }
+
+    if (!this.configuration.telemetryEnabled) {
+      this.log(LogLevel.DEBUG, 'Skipped reporting download because telemetry is disabled');
+      return;
+    }
+
+    const requestBody: ReportDownloadInput = {
+      client_unique_id: this.configuration.clientUniqueId,
+      deployment_key: this.configuration.releaseChannelPublicId,
+      label: downloadedPackage.label,
+    };
+
+    const url = `${this.configuration.serverUrl}/report_status/download`;
+
+    const response = await this.httpRequester.request('POST', url, JSON.stringify(requestBody));
+
+    if (response.statusCode < 200 || response.statusCode >= 300) {
+      throw new CodePushHttpError(url, response.statusCode, response.body || 'No body');
+    }
+  }
+}

package/src/internals/CodePushApiSdk.types.ts

@@ -0,0 +1,117 @@
+export interface ApiSdkQueryUpdatePackageInfo {
+  appVersion: string;
+  label?: string;
+  packageHash?: string;
+}
+
+export interface ApiSdkDeployReportPackageInfo {
+  label: string;
+  appVersion: string;
+}
+
+export interface ApiSdkDownloadReportPackageInfo {
+  label: string;
+}
+
+export interface ApiSdkRemotePackage {
+  releaseChannelPublicId: string;
+  label: string;
+  appVersion: string;
+  description: string;
+  isMandatory: boolean;
+  packageSize: number;
+  packageHash: string;
+  downloadUrl: string;
+}
+
+export interface ApiSdkNativeUpdateNotification {
+  updateAppVersion: true;
+  appVersion: string;
+}
+
+export namespace Http {
+  export interface Response {
+    statusCode: number;
+    body?: string;
+  }
+
+  export interface Requester {
+    request(verb: 'GET' | 'POST', url: string, requestBody?: string | object | null): Promise<Response>;
+  }
+}
+
+export interface ApiSdkConfiguration {
+  appVersion: string;
+  clientUniqueId: string;
+  releaseChannelPublicId: string;
+  serverUrl: string;
+  dataTransmissionEnabled: boolean;
+  telemetryEnabled: boolean;
+  ignoreAppVersion?: boolean;
+}
+
+/**
+ * Indicates the status of a deployment (after installing and restarting).
+ */
+export enum DeploymentStatus {
+  /**
+   * The deployment failed (and was rolled back).
+   */
+  FAILED = 'DeploymentFailed',
+
+  /**
+   * The deployment succeeded.
+   */
+  SUCCEEDED = 'DeploymentSucceeded',
+}
+
+export interface ReportDeployInput {
+  deployment_key: string;
+  app_version: string;
+  status?: DeploymentStatus;
+  label?: string;
+  client_unique_id?: string;
+  previous_label_or_app_version?: string;
+  previous_deployment_key?: string;
+}
+
+export interface ReportDownloadInput {
+  deployment_key: string;
+  label: string;
+  client_unique_id?: string;
+}
+
+export interface CheckUpdateRequestInput {
+  deployment_key: string;
+  app_version: string;
+  package_hash?: string;
+  label?: string;
+  client_unique_id?: string;
+  is_companion?: boolean;
+  previous_label_or_app_version?: string;
+  previous_deployment_key?: string;
+}
+
+export interface CheckUpdateResponse {
+  update_info:
+    | {
+        is_available: true;
+        target_binary_range: string;
+        description: string;
+        is_disabled: boolean;
+        is_mandatory: boolean;
+        rollout: number;
+        download_url: string;
+        package_size: number;
+        package_hash: string;
+        label: string;
+        should_run_binary_version: boolean;
+        update_app_version: boolean;
+      }
+    | {
+        is_available: false;
+        should_run_binary_version: boolean;
+        target_binary_range: string;
+        update_app_version?: boolean;
+      };
+}

package/src/internals/CodePushEventEmitter.ts

@@ -0,0 +1,4 @@
+import { NativeEventEmitter } from 'react-native';
+import { NativeRNAppZungCodePushModule } from './NativeRNAppZungCodePushModule';
+
+export const CodePushEventEmitter = new NativeEventEmitter(NativeRNAppZungCodePushModule);

package/src/internals/RNAppZungCodePushModuleSpec.ts

@@ -20,6 +20,7 @@ export interface Spec extends TurboModule {
   };
 
   getConfiguration(): Promise<Configuration>;
+  resetClientUniqueId(): Promise<string>;
 
   getUpdateMetadata(updateState: UpdateState): Promise<OmitFunctions<LocalPackage>>;
   installUpdate(
@@ -51,4 +52,10 @@ export interface Spec extends TurboModule {
 
   isFirstRun(packageHash: string): Promise<boolean>;
   isFailedUpdate(packageHash: string): Promise<boolean>;
+
+  setTelemetryEnabled(enabled: boolean): Promise<void>;
+  getTelemetryEnabled(): Promise<boolean>;
+
+  setDataTransmissionEnabled(enabled: boolean): Promise<void>;
+  getDataTransmissionEnabled(): Promise<boolean>;
 }

package/src/internals/RemotePackageImplementation.ts

@@ -1,6 +1,7 @@
-import type { Package } from 'code-push/script/acquisition-sdk';
-import { NativeEventEmitter } from 'react-native';
+import { LogLevel } from '../enums/LogLevel.enum';
 import type { DownloadProgressCallback, LocalPackage, RemotePackage } from '../types';
+import type { ApiSdkDownloadReportPackageInfo } from './CodePushApiSdk.types';
+import { CodePushEventEmitter } from './CodePushEventEmitter';
 import { LocalPackageImplementation } from './LocalPackageImplementation';
 import { NativeRNAppZungCodePushModule } from './NativeRNAppZungCodePushModule';
 import { log } from './utils/log';
@@ -8,7 +9,7 @@ import { log } from './utils/log';
 export class RemotePackageImpl implements RemotePackage {
   constructor(
     remotePackageData: Omit<RemotePackage, 'download'>,
-    reportStatusDownload?: (downloadedPackage: Package) => Promise<void>,
+    reportStatusDownload: (downloadedPackage: ApiSdkDownloadReportPackageInfo) => Promise<void>,
   ) {
     Object.assign(this, remotePackageData);
 
@@ -20,9 +21,8 @@ export class RemotePackageImpl implements RemotePackage {
       let downloadProgressSubscription;
 
       if (downloadProgressCallback) {
-        const codePushEventEmitter = new NativeEventEmitter(NativeRNAppZungCodePushModule);
         // Use event subscription to obtain download progress.
-        downloadProgressSubscription = codePushEventEmitter.addListener(
+        downloadProgressSubscription = CodePushEventEmitter.addListener(
           'CodePushDownloadProgress',
           downloadProgressCallback,
         );
@@ -38,12 +38,13 @@ export class RemotePackageImpl implements RemotePackage {
         );
 
         if (reportStatusDownload) {
-          reportStatusDownload({
-            ...this,
-            deploymentKey: this.releaseChannelPublicId,
-          }).catch((err) => {
-            log(`Report download status failed: ${err}`);
+          const timeoutPromise = new Promise<void>((resolve) => setTimeout(resolve, 250));
+          const reportPromise = reportStatusDownload({
+            label: this.label,
+          }).catch((error) => {
+            log(LogLevel.ERROR, `Report download status failed: ${error}`);
           });
+          await Promise.race([timeoutPromise, reportPromise]);
         }
 
         return new LocalPackageImplementation(downloadedPackage);

package/src/internals/getConfiguration.ts

@@ -10,3 +10,7 @@ export async function getConfiguration() {
 
   return config;
 }
+
+export async function reloadCachedConfiguration() {
+  config = await NativeRNAppZungCodePushModule.getConfiguration();
+}

package/src/internals/logger.ts

@@ -0,0 +1,46 @@
+import type { LogLevel } from '../enums/LogLevel.enum';
+
+export type LoggerFunction = (level: LogLevel, message: string) => void;
+
+const defaultLogger: LoggerFunction = (_level: LogLevel, message: string): void => {
+  console.log(`[CodePush] ${message}`);
+};
+
+let currentLogger: LoggerFunction = defaultLogger;
+
+/**
+ * Set a custom logger function to handle all CodePush logs
+ *
+ * @param logger A function that takes a log level and message and handles the logging
+ * @example
+ * ```
+ * import { setLogger, LogLevel } from '@appzung/react-native-code-push';
+ *
+ * // Custom logger that sends critical logs to a crash reporting service
+ * setLogger((level, message) => {
+ *   // Always log to console
+ *   console.log(`[CodePush] ${message}`);
+ *
+ *   // Send error logs to crash reporting
+ *   if (level === LogLevel.ERROR) {
+ *     MyCrashReportingService.log(`CodePush error: ${message}`);
+ *   }
+ * });
+ * ```
+ */
+export const setLogger = (logger: LoggerFunction): void => {
+  currentLogger = logger;
+};
+
+/**
+ * Get the current logger function
+ * @returns The current logger function
+ */
+export const getLogger = (): LoggerFunction => currentLogger;
+
+/**
+ * Reset the logger to the default implementation
+ */
+export const resetLogger = (): void => {
+  currentLogger = defaultLogger;
+};

package/src/internals/shouldUpdateBeIgnored.ts

@@ -1,3 +1,4 @@
+import { LogLevel } from '../enums/LogLevel.enum';
 import type { RemotePackage, RollbackRetryOptions, SyncOptions } from '../types';
 import { NativeRNAppZungCodePushModule } from './NativeRNAppZungCodePushModule';
 import type { LatestRollbackInfo } from './types';
@@ -20,17 +21,17 @@ function validateLatestRollbackInfo(latestRollbackInfo: LatestRollbackInfo, pack
 
 function validateRollbackRetryOptions(rollbackRetryOptions: RollbackRetryOptions) {
   if (typeof rollbackRetryOptions.delayInHours !== 'number') {
-    log("The 'delayInHours' rollback retry parameter must be a number.");
+    log(LogLevel.ERROR, "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.");
+    log(LogLevel.ERROR, "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.");
+    log(LogLevel.ERROR, "The 'maxRetryAttempts' rollback retry parameter cannot be less then 1.");
     return false;
   }
 
@@ -61,14 +62,14 @@ export async function shouldUpdateBeIgnored(remotePackage: RemotePackage | null
 
   const latestRollbackInfo = await NativeRNAppZungCodePushModule.getLatestRollbackInfo();
   if (!validateLatestRollbackInfo(latestRollbackInfo, remotePackage.packageHash)) {
-    log('The latest rollback info is not valid.');
+    log(LogLevel.ERROR, '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.');
+    log(LogLevel.INFO, 'Previous rollback should be ignored due to rollback retry options.');
     return false;
   }
 

package/src/internals/types.ts

@@ -1,6 +1,6 @@
-import type { Configuration as BaseConfiguration } from 'code-push/script/acquisition-sdk';
+import type { ApiSdkConfiguration } from './CodePushApiSdk.types';
 
-export interface Configuration extends BaseConfiguration {
+export interface Configuration extends ApiSdkConfiguration {
   releaseChannelPublicId: string;
   packageHash?: string;
 }