@bravemobile/react-native-code-push 8.3.0 → 9.0.0-alpha.0

package/typings/react-native-code-push.d.ts

@@ -13,6 +13,26 @@ export interface UpdateCheckRequest {
     package_hash?: string;
 }
 
+/**
+ * Alias for a string representing a released CodePush update version.
+ */
+export type ReleaseVersion = string;
+
+/**
+ * The interface representing the release information that the `releaseHistoryFetcher` function must return.
+ */
+export type ReleaseHistoryInterface = Record<ReleaseVersion, ReleaseInfo>;
+
+/**
+ * The interface that represents a single deployment history entry, which the `releaseHistoryFetcher` function should return.
+ */
+export interface ReleaseInfo {
+    enabled: boolean;
+    mandatory: boolean;
+    downloadUrl: string;
+    packageHash: string;
+}
+
 // from code-push SDK
 export interface UpdateCheckResponse {
     download_url?: string;
@@ -35,21 +55,9 @@ export interface CodePushOptions extends SyncOptions {
      */
     checkFrequency: CodePush.CheckFrequency;
     /**
-     * Specifies the location of the update's file. It should include the http scheme and host.
-     * It is used for self-hosting.
-     * Defaults to AppCenter storage.
+     * Specifies a function to get the release history.
      */
-    bundleHost?: string;
-    /**
-     * Specify a function to perform the update check.
-     * It can be used for self-hosting.
-     * Defaults to AppCenter update_check REST API request.
-     */
-    updateChecker?: (updateRequest: UpdateCheckRequest) => Promise<{ update_info: UpdateCheckResponse }>;
-    /**
-     * Specifies whether to run the original action, which queries AppCenter if an error occurs while running the `updateChecker` function.
-     */
-    fallbackToAppCenter?: boolean;
+    releaseHistoryFetcher: (updateRequest: UpdateCheckRequest) => Promise<ReleaseHistoryInterface>;
 }
 
 export interface DownloadProgress {
@@ -186,6 +194,14 @@ export interface SyncOptions {
      * one or more of the default values.
      */
     rollbackRetryOptions?: RollbackRetryOptions;
+
+    /**
+     * Specifies whether to ignore the update if the installation fails.
+     * If set to false, the update will be retried when the sync method is called, even if the previous installation attempt failed.
+     * However, depending on the deployment strategy, if an update that cannot be successfully installed is deployed, this option could result in an infinite update retry loop.
+     * Defaults to true.
+     */
+    ignoreFailedUpdates?: boolean;
 }
 
 export interface UpdateDialog {
@@ -286,7 +302,7 @@ declare function CodePush(options?: CodePushOptions): (x: any) => any;
  *
  * @param x the React Component that will decorated
  */
-declare function CodePush(x: any): any
+declare function CodePush(x: any): any;
 
 declare namespace CodePush {
     /**
@@ -309,7 +325,7 @@ declare namespace CodePush {
      *
      * @param updateState The state of the update you want to retrieve the metadata for. Defaults to UpdateState.RUNNING.
      */
-    function getUpdateMetadata(updateState?: UpdateState) : Promise<LocalPackage|null>;
+    function getUpdateMetadata(updateState?: UpdateState): Promise<LocalPackage|null>;
 
     /**
      * Notifies the CodePush runtime that an installed update is considered successful.
@@ -495,3 +511,62 @@ declare namespace CodePush {
 }
 
 export default CodePush;
+
+/**
+ * Interface for the config file required for `npx code-push` CLI operation.
+ *
+ * Please refer to the example code for implementation guidance.
+ */
+export interface CliConfigInterface {
+    /**
+     * Interface that must be implemented to upload CodePush bundle files to an arbitrary infrastructure.
+     *
+     * Used in the `release` command, and must return a URL that allows downloading the file after the upload is completed.
+     * The URL is recorded in the ReleaseHistory, and the CodePush runtime library downloads the bundle file from this address.
+     *
+     * @param source The relative path of the generated bundle file. (e.g., ./2f156929-e474-46cd-9c9c-27a841043d98)
+     * @param platform The target platform of the bundle file. This is the string passed when executing the CLI command. ('ios'/'android')
+     * @param identifier An additional identifier string. This can be used to distinguish execution environments by incorporating it into the upload path or file name. This string is passed when executing the CLI command.
+     */
+    bundleUploader: (
+        source: string,
+        platform: "ios" | "android",
+        identifier?: string,
+    ) => Promise<{downloadUrl: string}>;
+
+    /**
+     * Interface that must be implemented to retrieve ReleaseHistory information.
+     *
+     * Use `fetch`, `axios`, or similar methods to fetch the data and return it.
+     *
+     * @param targetBinaryVersion The target binary app version for which ReleaseHistory information is retrieved. This string is passed when executing the CLI command. (e.g., '1.0.0')
+     * @param platform The target platform for which the information is retrieved. This string is passed when executing the CLI command. ('ios'/'android')
+     * @param identifier An additional identifier string. This string is passed when executing the CLI command.
+     */
+    getReleaseHistory: (
+        targetBinaryVersion: string,
+        platform: "ios" | "android",
+        identifier?: string,
+    ) => Promise<ReleaseHistoryInterface>;
+
+    /**
+     * Interface that must be implemented to create or update ReleaseHistory information.
+     *
+     * Used in the `create-history`, `release`, and `update-history` commands.
+     * The created or modified object and the JSON file path containing the result of the command execution are provided.
+     * Implement this function to upload the file or call a REST API to update the release history.
+     *
+     * @param targetBinaryVersion The target binary app version for the ReleaseHistory. This string is passed when executing the CLI command. (e.g., '1.0.0')
+     * @param jsonFilePath The absolute path to a JSON file following the `ReleaseHistoryInterface` structure. The file is created in the project's root directory and deleted when the command execution completes.
+     * @param releaseInfo A plain object following the `ReleaseHistoryInterface` structure.
+     * @param platform The target platform. This string is passed when executing the CLI command. ('ios'/'android')
+     * @param identifier An additional identifier string. This string is passed when executing the CLI command.
+     */
+    setReleaseHistory: (
+        targetBinaryVersion: string,
+        jsonFilePath: string,
+        releaseInfo: ReleaseHistoryInterface,
+        platform: "ios" | "android",
+        identifier?: string,
+    ) => Promise<void>;
+}

package/versioning/BaseVersioning.js

@@ -0,0 +1,126 @@
+/**
+ * @type {BaseVersioning}
+ */
+class BaseVersioning {
+  /**
+   * @param {ReleaseHistoryInterface} releaseHistory
+   * @param {SortingMethod} sortingMethod
+   */
+  constructor(releaseHistory, sortingMethod) {
+    if (this.constructor == BaseVersioning) {
+      throw new Error("Abstract classes can't be instantiated.");
+    }
+    if (releaseHistory == null || sortingMethod == null) {
+      throw new Error("param releaseHistory and sortingMethod is needed");
+    }
+
+    /** @type {SortingMethod} */
+    this.sortingMethod = sortingMethod;
+
+    /** @type {ReleaseHistoryInterface} */
+    this.originalReleaseHistory = releaseHistory;
+
+    /** @type {[ReleaseVersion, ReleaseInfo][]} */
+    this.sortedReleaseHistory = Object.entries(releaseHistory).sort(
+      ([a], [b]) => this.sortingMethod(a, b)
+    );
+  }
+
+  /**
+   * @return {[ReleaseVersion, ReleaseInfo][]}
+   */
+  get sortedEnabledReleaseHistory() {
+    return this.sortedReleaseHistory.filter(([_, bundle]) => bundle.enabled);
+  }
+
+  /**
+   * @return {[ReleaseVersion, ReleaseInfo][]}
+   */
+  get sortedMandatoryReleaseHistory() {
+    return this.sortedEnabledReleaseHistory.filter(
+      ([_, bundle]) => bundle.mandatory
+    );
+  }
+
+  /**
+   * find latest release in releaseHistory
+   * @return {[ReleaseVersion, ReleaseInfo]}
+   */
+  findLatestRelease() {
+    const latestReleaseInfo = this.sortedEnabledReleaseHistory.at(0);
+
+    if (!latestReleaseInfo) {
+      throw new Error("There is no latest release.");
+    }
+
+    return latestReleaseInfo;
+  }
+
+  /**
+   * check if the update is mandatory
+   * @param {ReleaseVersion|undefined} runtimeVersion
+   * @return {boolean}
+   */
+  checkIsMandatory(runtimeVersion) {
+    if (this.shouldRollback(runtimeVersion)) {
+      // rollback is always mandatory
+      return true;
+    }
+
+    if (this.sortedMandatoryReleaseHistory.length === 0) {
+      return false;
+    }
+
+    if (!runtimeVersion) {
+      // This means that there is at least one mandatory update, but the update has not been installed yet.
+      // So, the update is mandatory.
+      return true;
+    }
+
+    const [latestMandatoryVersion, _] = this.sortedMandatoryReleaseHistory[0];
+    const [larger] = [latestMandatoryVersion, runtimeVersion].sort(this.sortingMethod);
+
+    return runtimeVersion !== latestMandatoryVersion && larger === latestMandatoryVersion;
+  }
+
+  /**
+   * determine whether to rollback and execute it
+   * @param {ReleaseVersion|undefined} runtimeVersion
+   * @return {boolean}
+   */
+  shouldRollback(runtimeVersion) {
+    if (!runtimeVersion) {
+      // Rollback is not possible because no updates have been installed.
+      return false;
+    }
+
+    const [latestRelease] = this.findLatestRelease();
+    const [larger] = [latestRelease, runtimeVersion].sort(this.sortingMethod);
+
+    return runtimeVersion !== latestRelease && larger === runtimeVersion;
+  }
+
+  /**
+   * Determine whether to clear the currently running bundle.
+   * If it returns true, the CodePush bundle will be erased, and the app will restart.
+   * @param {ReleaseVersion} runtimeVersion
+   * @return {boolean}
+   */
+  shouldRollbackToBinary(runtimeVersion) {
+    if (!runtimeVersion) {
+      // Rollback is not possible because no updates have been installed.
+      return false;
+    }
+
+    const [latestReleaseVersion] = this.findLatestRelease();
+    const [binaryAppVersion] = this.sortedReleaseHistory.at(-1);
+
+    return (
+      runtimeVersion !== latestReleaseVersion &&
+      this.shouldRollback(runtimeVersion) &&
+      latestReleaseVersion === binaryAppVersion
+    );
+  }
+}
+
+module.exports = { BaseVersioning: BaseVersioning };

package/versioning/BaseVersioning.test.js

@@ -0,0 +1,15 @@
+import { BaseVersioning } from "./BaseVersioning"
+
+describe('BaseVersioning', () => {
+    describe('constructor', () => {
+        it('should throw an error if it is directly instantiated', () => {
+            expect(() => new BaseVersioning({})).toThrow("Abstract classes can't be instantiated.")
+        })
+
+        it('should throw an error if releaseHistory is not defined', () => {
+            class TestVersioning extends BaseVersioning {}
+            expect(() => new TestVersioning()).toThrow("param releaseHistory and sortingMethod is needed")
+            expect(() => new TestVersioning({}, () => {})).not.toThrow("param releaseHistory and sortingMethod is needed")
+        })
+    })
+})

package/versioning/IncrementalVersioning.js

@@ -0,0 +1,9 @@
+const { BaseVersioning } = require("./BaseVersioning");
+
+class IncrementalVersioning extends BaseVersioning {
+  constructor(releaseHistory) {
+    super(releaseHistory, (v1, v2) => Number(v2) - Number(v1));
+  }
+}
+
+module.exports = { IncrementalVersioning };

package/versioning/IncrementalVersioning.test.js

@@ -0,0 +1,186 @@
+import { IncrementalVersioning } from "./IncrementalVersioning"
+
+describe('Incremental Versioning Test', () => {
+    const MOCK_INFOS = { downloadUrl: '', packageHash: '' }
+
+    // When major version is released, it must be considered like below
+    const FIRST_RELEASE_INFO = { enabled: true, mandatory: false, ...MOCK_INFOS };
+
+    describe('findLatestRelease', () => {
+        it('should throw error when there is no releases', () => {
+            const RELEASED_BUNDLES_1 = {}
+            const RELEASED_BUNDLES_2 = {'1': { enabled: false, mandatory: false, downloadUrl: 'R1', packageHash: 'P1' }}
+            expect(() => new IncrementalVersioning(RELEASED_BUNDLES_1).findLatestRelease())
+                .toThrow("There is no latest release.")
+            expect(() => new IncrementalVersioning(RELEASED_BUNDLES_2).findLatestRelease())
+                .toThrow("There is no latest release.")
+        })
+
+        it('should return latest release', () => {
+            const RELEASED_BUNDLES = {
+                '1': { enabled: true, mandatory: false, downloadUrl: 'R1', packageHash: 'P1' },
+                '2': { enabled: true, mandatory: false, downloadUrl: 'R2', packageHash: 'P2' },
+                '3': { enabled: true, mandatory: true, downloadUrl: 'R3', packageHash: 'P3' },
+            };
+
+            expect(new IncrementalVersioning(RELEASED_BUNDLES).findLatestRelease()).toEqual([
+                '3',
+                { enabled: true, mandatory: true, downloadUrl: 'R3', packageHash: 'P3' }
+            ])
+        })
+
+        it('should ignore not-enabled bundles and return latest release', () => {
+            const RELEASED_BUNDLES_1 = {
+                '1': { enabled: true, mandatory: false, downloadUrl: 'R1', packageHash: 'P1' },
+                '2': { enabled: false, mandatory: false, downloadUrl: 'R2', packageHash: 'P2' },
+            };
+
+            const RELEASED_BUNDLES_2 = {
+                '1': { enabled: true, mandatory: false, downloadUrl: 'R1', packageHash: 'P1' },
+                '2': { enabled: false, mandatory: false, downloadUrl: 'R2', packageHash: 'P2' },
+                '3': { enabled: true, mandatory: true, downloadUrl: 'R3', packageHash: 'P3' },
+            };
+
+            expect(new IncrementalVersioning(RELEASED_BUNDLES_1).findLatestRelease()).toEqual([
+                '1',
+                { enabled: true, mandatory: false, downloadUrl: 'R1', packageHash: 'P1' }
+            ])
+
+            expect(new IncrementalVersioning(RELEASED_BUNDLES_2).findLatestRelease()).toEqual([
+                '3',
+                { enabled: true, mandatory: true, downloadUrl: 'R3', packageHash: 'P3' }
+            ])
+        })
+    })
+
+    describe('checkIsMandatory', () => {
+        describe('not-mandatory cases', () => {
+            it('should consider not-mandatory when the first major version is released', () => {
+                const RUNTIME_VERSION = '1';
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                };
+        
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(false);
+            });
+        
+            it('should consider not-mandatory when latest version is running', () => {
+                const RUNTIME_VERSION = '3';
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                    '2': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                    '3': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                };
+        
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(false);
+            });
+
+            it('should consider not-mandatory when only not-mandatory version is released', () => {
+                const RUNTIME_VERSION = '1';
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                    '2': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                };
+        
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(false);
+            });
+
+            it('should consider not-mandatory when only not-mandatory version is released after current runtime version', () => {
+                const RUNTIME_VERSION = '2';
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                    '2': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '3': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                };
+        
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(false);
+            });
+        })
+
+        describe('mandatory cases', () => {
+            it('should consider mandatory when mandatory release exists', () => {
+                const RUNTIME_VERSION = '1';
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                    '2': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                };
+        
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(true);
+            });
+
+            it("should consider mandatory if there's a mandatory release between the runtime version and the latest", () => {
+                const RUNTIME_VERSION = '1'
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                    '2': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '3': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                }
+
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory(RUNTIME_VERSION)).toBe(true);
+            })
+
+            it('should consider mandatory when latest version < current runtime version (ROLLBACK)', () => {
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                };
+                const currentVersion = '2'
+    
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).shouldRollback(currentVersion)).toBe(true)
+            })
+        })
+
+        describe('scenario test', () => {
+            it('Major Release > Mandatory > Not-mandatory > Mandatory > Not-mandatory', () => {
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                    '2': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '3': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                    '4': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '5': { enabled: true, mandatory: false, ...MOCK_INFOS },
+                };
+
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('1')).toBe(true);
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('2')).toBe(true);
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('3')).toBe(true);
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('4')).toBe(false);
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('5')).toBe(false);
+            });
+
+            it('When having not-enabled releases', () => {
+                const RELEASED_BUNDLES = {
+                    '1': FIRST_RELEASE_INFO,
+                    '2': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '3': { enabled: false, mandatory: false, ...MOCK_INFOS },
+                    '4': { enabled: true, mandatory: true, ...MOCK_INFOS },
+                    '5': { enabled: false, mandatory: false, ...MOCK_INFOS },
+                };
+
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('1')).toBe(true);
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('2')).toBe(true);
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('3')).toBe(true);
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('4')).toBe(false);
+                expect(new IncrementalVersioning(RELEASED_BUNDLES).checkIsMandatory('5')).toBe(true);
+            });
+        })
+    })
+
+    describe('shouldRollbackToBinary', () => {
+        it('should return true when destination version is the first major version', () => {
+            const RELEASED_BUNDLES = {
+                '1': FIRST_RELEASE_INFO,
+                '2': { enabled: false, mandatory: true, ...MOCK_INFOS },
+            };
+
+            expect(new IncrementalVersioning(RELEASED_BUNDLES).shouldRollbackToBinary('2')).toBe(true)
+        })
+
+        it('should return false when runtime version is the same as destination version', () => {
+            const RELEASED_BUNDLES = {
+                '1': FIRST_RELEASE_INFO,
+                '2': { enabled: false, mandatory: true, ...MOCK_INFOS },
+            };
+
+            expect(new IncrementalVersioning(RELEASED_BUNDLES).shouldRollbackToBinary('1')).toBe(false)
+        })
+    })
+})

package/versioning/SemverVersioning.js

@@ -0,0 +1,10 @@
+const Semver = require("semver");
+const { BaseVersioning } = require("./BaseVersioning");
+
+class SemverVersioning extends BaseVersioning {
+  constructor(releaseHistory) {
+    super(releaseHistory, (v1, v2) => (Semver.gt(v1, v2) ? -1 : 1));
+  }
+}
+
+module.exports = { SemverVersioning };