@appzung/react-native-code-push 10.0.1 → 10.1.1

package/src/internals/CodePushApiSdk.ts

@@ -0,0 +1,133 @@
+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,
+    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> {
+    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> {
+    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> {
+    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,115 @@
+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;
+  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/RNAppZungCodePushModuleSpec.ts

@@ -20,6 +20,7 @@ export interface Spec extends TurboModule {
   };
 
   getConfiguration(): Promise<Configuration>;
+  resetClientUniqueId(): Promise<string>;
 
   getUpdateMetadata(updateState: UpdateState): Promise<OmitFunctions<LocalPackage>>;
   installUpdate(

package/src/internals/RemotePackageImplementation.ts

@@ -1,6 +1,6 @@
-import type { Package } from 'code-push/script/acquisition-sdk';
 import { NativeEventEmitter } from 'react-native';
 import type { DownloadProgressCallback, LocalPackage, RemotePackage } from '../types';
+import type { ApiSdkDownloadReportPackageInfo } from './CodePushApiSdk.types';
 import { LocalPackageImplementation } from './LocalPackageImplementation';
 import { NativeRNAppZungCodePushModule } from './NativeRNAppZungCodePushModule';
 import { log } from './utils/log';
@@ -8,7 +8,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);
 
@@ -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(`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/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;
 }

package/src/internals/utils/fetchRetry.ts

@@ -0,0 +1,72 @@
+export async function fetchRetry(url: string, options: FetchRetryOptions = {}, attempt = 0): Promise<Response> {
+  const {
+    maxRetries = 3,
+    initialBackoff = 1000,
+    backoffMultiplier = 2,
+    maxRetryDelay = 30000,
+    ...fetchOptions
+  } = options;
+
+  try {
+    const response = await fetch(url, fetchOptions);
+    if (response.ok || !(response.status === 429 || response.status >= 500)) {
+      return response;
+    }
+
+    if (attempt >= maxRetries) {
+      return response;
+    }
+
+    const retryAfter = parseRetryAfterHeader(response);
+    if (retryAfter && retryAfter > maxRetryDelay) {
+      return response;
+    }
+
+    const delay = retryAfter ?? addJitter(initialBackoff * Math.pow(backoffMultiplier, attempt));
+
+    await new Promise((resolve) => setTimeout(resolve, delay));
+
+    return fetchRetry(url, options, attempt + 1);
+  } catch (error) {
+    if (attempt >= maxRetries) {
+      throw error;
+    }
+
+    const delay = addJitter(initialBackoff * Math.pow(backoffMultiplier, attempt));
+
+    await new Promise((resolve) => setTimeout(resolve, delay));
+
+    return fetchRetry(url, options, attempt + 1);
+  }
+}
+
+interface FetchRetryOptions extends RequestInit {
+  maxRetries?: number;
+  initialBackoff?: number;
+  backoffMultiplier?: number;
+  maxRetryDelay?: number;
+}
+
+function parseRetryAfterHeader(response: Response): number | null {
+  const retryAfter = response.headers.get('Retry-After');
+  if (!retryAfter) {
+    return null;
+  }
+
+  if (!isNaN(Number(retryAfter))) {
+    return parseInt(retryAfter, 10) * 1000;
+  }
+
+  try {
+    const retryDate = new Date(retryAfter).getTime();
+    const now = Date.now();
+    return retryDate > now ? retryDate - now : 0;
+  } catch (e) {
+    return null;
+  }
+}
+
+function addJitter(delay: number): number {
+  const jitterFactor = 0.5 + Math.random() * 0.5;
+  return Math.floor(delay * jitterFactor);
+}

package/src/internals/utils/queryStringify.ts

@@ -0,0 +1,22 @@
+export function queryStringify(object: { [key: string]: any }): string {
+  let queryString = '';
+  let isFirst = true;
+
+  for (const property in object) {
+    if (object.hasOwnProperty(property)) {
+      const value = object[property];
+      if (value !== null && typeof value !== 'undefined') {
+        if (!isFirst) {
+          queryString += '&';
+        }
+
+        queryString += encodeURIComponent(property) + '=';
+        queryString += encodeURIComponent(value);
+      }
+
+      isFirst = false;
+    }
+  }
+
+  return queryString;
+}

package/src/internals/utils/requestFetchAdapter.ts

@@ -0,0 +1,28 @@
+import type { Http } from '../CodePushApiSdk.types';
+import { version } from '../version';
+import { fetchRetry } from './fetchRetry';
+
+export const requestFetchAdapter: Http.Requester = {
+  async request(method, url, requestBody) {
+    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);
+    }
+
+    const response = await fetchRetry(url, {
+      method,
+      headers,
+      body: requestBody,
+    });
+
+    const statusCode = response.status;
+    const body = await response.text();
+    return { statusCode, body };
+  },
+};

package/src/internals/version.ts

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

package/src/notifyAppReady.ts

@@ -1,13 +1,15 @@
 import { AppState, type NativeEventSubscription } from 'react-native';
+import { CodePushApiSdk } from './internals/CodePushApiSdk';
 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 { requestFetchAdapter } from './internals/utils/requestFetchAdapter';
 import type { StatusReport } from './types';
 
 /**
  * Notifies the CodePush runtime that an installed update is considered successful.
+ *
+ * If you are manually checking for and installing updates (i.e. not using the `sync` method to handle it all for you), then this method **MUST** be called; otherwise CodePush will treat the update as failed and rollback to the previous version when the app next restarts.
  */
 export const notifyAppReady = (() => {
   // This ensures that notifyApplicationReadyInternal is only called once
@@ -33,7 +35,7 @@ async function notifyApplicationReadyInternal() {
 
 async function tryReportStatus(statusReport: StatusReport, retryOnAppResume?: NativeEventSubscription) {
   const config = await getConfiguration();
-  const previousLabelOrAppVersion = statusReport.previousLabelOrAppVersion;
+  const previousLabelOrAppVersion = statusReport.previousLabelOrAppVersion ?? null;
   const previousReleaseChannelPublicId = statusReport.previousReleaseChannelPublicId || config.releaseChannelPublicId;
   try {
     if (statusReport.appVersion) {
@@ -43,13 +45,8 @@ async function tryReportStatus(statusReport: StatusReport, retryOnAppResume?: Na
         throw new Error('Release channel is missing');
       }
 
-      const sdk = getPromisifiedSdk(requestFetchAdapter, config);
-      await sdk.reportStatusDeploy(
-        /* deployedPackage */ undefined,
-        /* status */ undefined,
-        previousLabelOrAppVersion,
-        previousReleaseChannelPublicId,
-      );
+      const sdk = new CodePushApiSdk(requestFetchAdapter, config);
+      await sdk.reportStatusDeploy(null, previousLabelOrAppVersion, previousReleaseChannelPublicId);
     } else {
       if (!statusReport.package) {
         throw new Error('Missing package in status report');
@@ -64,10 +61,12 @@ async function tryReportStatus(statusReport: StatusReport, retryOnAppResume?: Na
       }
 
       config.releaseChannelPublicId = statusReport.package.releaseChannelPublicId;
-      const sdk = getPromisifiedSdk(requestFetchAdapter, config);
+      const sdk = new CodePushApiSdk(requestFetchAdapter, config);
       await sdk.reportStatusDeploy(
-        { ...statusReport.package, deploymentKey: statusReport.package.releaseChannelPublicId },
-        statusReport.status,
+        {
+          package: statusReport.package,
+          status: statusReport.status,
+        },
         previousLabelOrAppVersion,
         previousReleaseChannelPublicId,
       );

package/src/resetClientUniqueId.ts

@@ -0,0 +1,11 @@
+import { NativeRNAppZungCodePushModule } from './internals/NativeRNAppZungCodePushModule';
+import { reloadCachedConfiguration } from './internals/getConfiguration';
+
+/**
+ * Resets the client's unique ID. You may use this in some GDPR compliance scenarios. Note that this will create a new MAU if a new request is sent later.
+ */
+export const resetClientUniqueId = async () => {
+  const newId = await NativeRNAppZungCodePushModule.resetClientUniqueId();
+  await reloadCachedConfiguration();
+  return newId;
+};

package/src/restartApp.ts

@@ -3,6 +3,8 @@ import { NativeRNAppZungCodePushModule } from './internals/NativeRNAppZungCodePu
 /**
  * Immediately restarts the app.
  *
+ * If there is an update pending, it will be immediately displayed to the end user. Otherwise, calling this method simply has the same behavior as the end user killing and restarting the process.
+ *
  * @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) {

package/src/sync.ts

@@ -206,6 +206,8 @@ async function syncInternal(
 /**
  * Allows checking for an update, downloading it and installing it, all with a single call.
  *
+ * Unless you need custom UI and/or behavior, we recommend most developers to use this method when integrating CodePush into their apps, if they are not using the `withCodePush` HOC.
+ *
  * @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.
@@ -222,17 +224,17 @@ export const sync = (() => {
 
   return (
     options?: SyncOptions,
-    syncStatusChangeCallback?: SyncStatusChangedCallback,
+    syncStatusChangedCallback?: SyncStatusChangedCallback,
     downloadProgressCallback?: DownloadProgressCallback,
     handleBinaryVersionMismatchCallback?: HandleBinaryVersionMismatchCallback,
   ): Promise<SyncStatus> => {
     let syncStatusCallbackWithTryCatch: SyncStatusChangedCallback | undefined;
     let downloadProgressCallbackWithTryCatch: DownloadProgressCallback | undefined;
 
-    if (typeof syncStatusChangeCallback === 'function') {
+    if (typeof syncStatusChangedCallback === 'function') {
       syncStatusCallbackWithTryCatch = (...args) => {
         try {
-          syncStatusChangeCallback(...args);
+          syncStatusChangedCallback(...args);
         } catch (error) {
           log(`An error has occurred : ${error instanceof Error ? error.stack : 'unknown'}`);
         }