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

package/babel-plugin-code-push/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@bravemobile/babel-plugin-code-push",
+  "version": "1.0.0",
+  "description": "Babel plugin for @bravemobile/react-native-code-push",
+  "main": "index.js",
+  "scripts": {
+    "test": "cd test && jest"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@bravemobile/react-native-code-push": "../"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.25.9",
+    "@babel/core": "^7.26.0",
+    "@babel/node": "^7.26.0",
+    "@babel/preset-env": "^7.26.0",
+    "@types/shelljs": "^0.8.15",
+    "babel-cli": "^6.26.0",
+    "babel-jest": "^29.7.0",
+    "jest": "^29.7.0",
+    "shelljs": "^0.8.5"
+  }
+}

package/babel-plugin-code-push/test/.babelrc.js

@@ -0,0 +1,12 @@
+module.exports = function (api) {
+  if (api.env("test")) {
+    return {
+      presets: [["@babel/preset-env", { targets: { node: "current" } }]],
+      plugins: [["../index.js"]],
+    };
+  }
+
+  return {
+    plugins: [["../index.js"]],
+  };
+};

package/babel-plugin-code-push/test/cases/test1-config

@@ -0,0 +1,15 @@
+const {
+  SemverVersioning,
+} = require("@bravemobile/react-native-code-push/versioning");
+
+class CustomVersioning extends SemverVersioning {
+  constructor() {
+    super();
+  }
+}
+
+module.exports = {
+  bundleHost: "bundleHost",
+  runtimeVersion: "runtimeVersion",
+  versioning: CustomVersioning,
+};

package/babel-plugin-code-push/test/cases/test1-input

@@ -0,0 +1,3 @@
+import codePush from "@bravemobile/react-native-code-push";
+
+codePush();

package/babel-plugin-code-push/test/cases/test1-output

@@ -0,0 +1,11 @@
+import { SemverVersioning } from "@bravemobile/react-native-code-push/versioning";
+import codePush from "@bravemobile/react-native-code-push";
+codePush({
+  bundleHost: "bundleHost",
+  runtimeVersion: "runtimeVersion",
+  versioning: class CustomVersioning extends SemverVersioning {
+    constructor() {
+      super();
+    }
+  }
+});

package/babel-plugin-code-push/test/cases/test2-config

@@ -0,0 +1,9 @@
+const {
+  SemverVersioning,
+} = require("@bravemobile/react-native-code-push/versioning");
+
+module.exports = {
+  bundleHost: "bundleHost",
+  runtimeVersion: "runtimeVersion",
+  versioning: SemverVersioning,
+};

package/babel-plugin-code-push/test/cases/test2-input

@@ -0,0 +1,3 @@
+import codePush from "@bravemobile/react-native-code-push";
+
+codePush();

package/babel-plugin-code-push/test/cases/test2-output

@@ -0,0 +1,7 @@
+import { SemverVersioning } from "@bravemobile/react-native-code-push/versioning";
+import codePush from "@bravemobile/react-native-code-push";
+codePush({
+  bundleHost: "bundleHost",
+  runtimeVersion: "runtimeVersion",
+  versioning: SemverVersioning
+});

package/babel-plugin-code-push/test/codepush.config.js

@@ -0,0 +1,15 @@
+const {
+  SemverVersioning,
+} = require("@bravemobile/react-native-code-push/versioning");
+
+class CustomVersioning extends SemverVersioning {
+  constructor() {
+    super();
+  }
+}
+
+module.exports = {
+  bundleHost: "bundleHost",
+  runtimeVersion: "runtimeVersion",
+  versioning: CustomVersioning,
+};

package/babel-plugin-code-push/test/plugin.test.js

@@ -0,0 +1,44 @@
+import fs from "fs";
+import { transformSync } from "@babel/core";
+
+describe("babel plugin", () => {
+  test("case1: using custom Versioning class", () => {
+    const input = fs.readFileSync("./cases/test1-input", { encoding: "utf-8" });
+    const expected = fs.readFileSync("./cases/test1-output", {
+      encoding: "utf-8",
+    });
+
+    const generated = transformSync(input, {
+      plugins: [
+        [
+          "../index.js",
+          {
+            configPath: "./cases/test1-config",
+          },
+        ],
+      ],
+    });
+
+    expect(generated.code).toBe(expected);
+  });
+
+  test("case2: using provided Versioning class", () => {
+    const input = fs.readFileSync("./cases/test2-input", { encoding: "utf-8" });
+    const expected = fs.readFileSync("./cases/test2-output", {
+      encoding: "utf-8",
+    });
+
+    const generated = transformSync(input, {
+      plugins: [
+        [
+          "../index.js",
+          {
+            configPath: "./cases/test2-config",
+          },
+        ],
+      ],
+    });
+
+    expect(generated.code).toBe(expected);
+  });
+});

package/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+    presets: [['@babel/preset-env', {targets: {node: 'current'}}]],
+};

package/cli/commands/bundleCommand/bundleCodePush.js

@@ -0,0 +1,49 @@
+const { prepareToBundleJS } = require('../../functions/prepareToBundleJS');
+const { runReactNativeBundleCommand } = require('../../functions/runReactNativeBundleCommand');
+const { getReactTempDir } = require('../../functions/getReactTempDir');
+const { runHermesEmitBinaryCommand } = require('../../functions/runHermesEmitBinaryCommand');
+const { makeCodePushBundle } = require('../../functions/makeCodePushBundle');
+
+/**
+ * @param platform {string} 'ios' | 'android'
+ * @param outputRootPath {string}
+ * @param entryFile {string}
+ * @param bundleName {string|undefined}
+ * @return {Promise<{bundleFileName: string, packageHash: string}>}
+ */
+async function bundleCodePush(
+  platform = 'ios',
+  outputRootPath = 'build',
+  entryFile = 'index.ts',
+  bundleName,
+) {
+    const OUTPUT_CONTENT_PATH = `${outputRootPath}/CodePush`;
+    const BUNDLE_NAME_DEFAULT = platform === 'ios' ? 'main.jsbundle' : 'index.android.bundle';
+    const _bundleName = bundleName ? bundleName : BUNDLE_NAME_DEFAULT;
+    const SOURCEMAP_OUTPUT = `${outputRootPath}/${_bundleName}.map`;
+
+    prepareToBundleJS({ deleteDirs: [outputRootPath, getReactTempDir()], makeDir: OUTPUT_CONTENT_PATH });
+
+    runReactNativeBundleCommand(
+      _bundleName,
+      OUTPUT_CONTENT_PATH,
+      platform,
+      SOURCEMAP_OUTPUT,
+      entryFile,
+    );
+    console.log('log: JS bundling complete');
+
+    await runHermesEmitBinaryCommand(
+      _bundleName,
+      OUTPUT_CONTENT_PATH,
+      SOURCEMAP_OUTPUT,
+    );
+    console.log('log: Hermes compilation complete');
+
+    const { bundleFileName, packageHash } = await makeCodePushBundle(OUTPUT_CONTENT_PATH);
+    console.log(`log: CodePush bundle created (file name: ${bundleFileName})`);
+
+    return { bundleFileName, packageHash }; // returns for release command implementation
+}
+
+module.exports = { bundleCodePush: bundleCodePush };

package/cli/commands/bundleCommand/index.js

@@ -0,0 +1,25 @@
+const { program, Option } = require("commander");
+const { bundleCodePush } = require("./bundleCodePush");
+
+program.command('bundle')
+    .description('Creates a CodePush bundle file (assumes Hermes is enabled).')
+    .addOption(new Option('-p, --platform <type>', 'platform').choices(['ios', 'android']).default('ios'))
+    .option('-o, --output-path <string>', 'path to output root directory', 'build')
+    .option('-e, --entry-file <string>', 'path to JS/TS entry file', 'index.ts')
+    .option('-b, --bundle-name <string>', 'bundle file name (default-ios: "main.jsbundle" / default-android: "index.android.bundle")')
+    /**
+     * @param {Object} options
+     * @param {string} options.platform
+     * @param {string} options.outputPath
+     * @param {string} options.entryFile
+     * @param {string} options.bundleName
+     * @return {void}
+     */
+    .action((options) => {
+        bundleCodePush(
+            options.platform,
+            options.outputPath,
+            options.entryFile,
+            options.bundleName,
+        )
+    });

package/cli/commands/createHistoryCommand/createReleaseHistory.js

@@ -0,0 +1,53 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ *
+ * @param targetVersion {string}
+ * @param setReleaseHistory {
+ *   function(
+ *     targetBinaryVersion: string,
+ *     jsonFilePath: string,
+ *     releaseInfo: ReleaseHistoryInterface,
+ *     platform: string,
+ *     identifier: string
+ *   ): Promise<void>}
+ * @param platform {"ios" | "android"}
+ * @param identifier {string}
+ * @returns {Promise<void>}
+ */
+async function createReleaseHistory(
+    targetVersion,
+    setReleaseHistory,
+    platform,
+    identifier,
+) {
+    const BINARY_RELEASE = {
+        enabled: true,
+        mandatory: false,
+        downloadUrl: "",
+        packageHash: "",
+    };
+
+    /** @type {ReleaseHistoryInterface} */
+    const INITIAL_HISTORY = {
+        [targetVersion]: BINARY_RELEASE
+    };
+
+    try {
+        const JSON_FILE_NAME = `${targetVersion}.json`;
+        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
+
+        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(INITIAL_HISTORY, null, 2));
+        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(INITIAL_HISTORY));
+
+        await setReleaseHistory(targetVersion, JSON_FILE_PATH, INITIAL_HISTORY, platform, identifier)
+
+        fs.unlinkSync(JSON_FILE_PATH);
+    } catch (error) {
+        console.error('Error occurred while creating new history:', error);
+        process.exit(1)
+    }
+}
+
+module.exports = { createReleaseHistory: createReleaseHistory }

package/cli/commands/createHistoryCommand/index.js

@@ -0,0 +1,28 @@
+const { program, Option } = require("commander");
+const { findAndReadConfigFile } = require("../../utils/fsUtils");
+const { createReleaseHistory } = require("./createReleaseHistory");
+
+program.command('create-history')
+    .description('Creates a new release history for the binary app.')
+    .requiredOption('-b, --binary-version <string>', '(Required) The target binary version')
+    .addOption(new Option('-p, --platform <type>', 'platform').choices(['ios', 'android']).default('ios'))
+    .option('-i, --identifier <string>', 'reserved characters to distinguish the release.')
+    .option('-c, --config <path>', 'set config file name (JS/TS)', 'code-push.config.ts')
+    /**
+     * @param {Object} options
+     * @param {string} options.binaryVersion
+     * @param {string} options.platform
+     * @param {string} options.identifier
+     * @param {string} options.config
+     * @return {void}
+     */
+    .action(async (options) => {
+        const config = findAndReadConfigFile(process.cwd(), options.config);
+
+        await createReleaseHistory(
+            options.binaryVersion,
+            config.setReleaseHistory,
+            options.platform,
+            options.identifier
+        );
+    });

package/cli/commands/releaseCommand/addToReleaseHistory.js

@@ -0,0 +1,75 @@
+const path = require("path");
+const fs = require("fs");
+
+/**
+ *
+ * @param appVersion {string}
+ * @param binaryVersion {string}
+ * @param bundleDownloadUrl {string}
+ * @param packageHash {string}
+ * @param getReleaseHistory {
+ *   function(
+ *     targetBinaryVersion: string,
+ *     platform: string,
+ *     identifier?: string
+ *   ): Promise<ReleaseHistoryInterface>}
+ * @param setReleaseHistory {
+ *   function(
+ *     targetBinaryVersion: string,
+ *     jsonFilePath: string,
+ *     releaseInfo: ReleaseHistoryInterface,
+ *     platform: string,
+ *     identifier?: string
+ *   ): Promise<void>}
+ * @param platform {"ios" | "android"}
+ * @param identifier {string?}
+ * @param mandatory {boolean?}
+ * @param enable {boolean?}
+ * @returns {Promise<void>}
+ */
+async function addToReleaseHistory(
+    appVersion,
+    binaryVersion,
+    bundleDownloadUrl,
+    packageHash,
+    getReleaseHistory,
+    setReleaseHistory,
+    platform,
+    identifier,
+    mandatory,
+    enable,
+) {
+    const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
+
+    const updateInfo = releaseHistory[appVersion]
+    if (updateInfo) {
+        console.error(`v${appVersion} is already released`)
+        process.exit(1)
+    }
+
+    const newReleaseHistory = structuredClone(releaseHistory);
+
+    newReleaseHistory[appVersion] = {
+        enabled: enable,
+        mandatory: mandatory,
+        downloadUrl: bundleDownloadUrl,
+        packageHash: packageHash,
+    }
+
+    try {
+        const JSON_FILE_NAME = `${binaryVersion}.json`;
+        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
+
+        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(newReleaseHistory, null, 2));
+        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(newReleaseHistory));
+
+        await setReleaseHistory(binaryVersion, JSON_FILE_PATH, newReleaseHistory, platform, identifier)
+
+        fs.unlinkSync(JSON_FILE_PATH);
+    } catch (error) {
+        console.error('Error occurred while updating history:', error);
+        process.exit(1)
+    }
+}
+
+module.exports = { addToReleaseHistory: addToReleaseHistory }

package/cli/commands/releaseCommand/index.js

@@ -0,0 +1,61 @@
+const { program, Option } = require("commander");
+const SemVer = require('semver');
+const { findAndReadConfigFile } = require("../../utils/fsUtils");
+const { release } = require("./release");
+
+program.command('release')
+    .description('Deploys a new CodePush update for a target binary app.\nAfter creating the CodePush bundle, it uploads the file and updates the ReleaseHistory information.\n`bundleUploader`, `getReleaseHistory`, and `setReleaseHistory` functions should be implemented in the config file.')
+    .requiredOption('-v, --app-version <string>', '(Required) The app version to be released. It must be greater than the binary version.')
+    .addOption(new Option('-p, --platform <type>', 'platform').choices(['ios', 'android']).default('ios'))
+    .option('-i, --identifier <string>', 'reserved characters to distinguish the release.')
+    .option('-c, --config <path>', 'set config file name (JS/TS)', 'code-push.config.ts')
+    .option('-o, --output-path <string>', 'path to output root directory', 'build')
+    .option('-e, --entry-file <string>', 'path to JS/TS entry file', 'index.ts')
+    .option('-j, --js-bundle-name <string>', 'JS bundle file name (default-ios: "main.jsbundle" / default-android: "index.android.bundle")')
+    .option('-m, --mandatory <bool>', 'make the release to be mandatory', parseBoolean, false)
+    .option('--enable <bool>', 'make the release to be enabled', parseBoolean, true)
+    /**
+     * @param {Object} options
+     * @param {string} options.binaryVersion
+     * @param {string} options.appVersion
+     * @param {string} options.platform
+     * @param {string} options.identifier
+     * @param {string} options.config
+     * @param {string} options.outputPath
+     * @param {string} options.entryFile
+     * @param {string} options.bundleName
+     * @param {string} options.mandatory
+     * @param {string} options.enable
+     * @return {void}
+     */
+    .action(async (options) => {
+        if (SemVer.lte(options.appVersion, options.binaryVersion)) {
+            console.error('The app version must be greater than the binary version.');
+            process.exit(1);
+        }
+
+        const config = findAndReadConfigFile(process.cwd(), options.config);
+
+        await release(
+            config.bundleUploader,
+            config.getReleaseHistory,
+            config.setReleaseHistory,
+            options.binaryVersion,
+            options.appVersion,
+            options.platform,
+            options.identifier,
+            options.outputPath,
+            options.entryFile,
+            options.bundleName,
+            options.mandatory,
+            options.enable,
+        )
+
+        console.log('🚀 Release completed.')
+    });
+
+function parseBoolean(value) {
+    if (value === 'true') return true;
+    if (value === 'false') return false;
+    else return undefined;
+}

package/cli/commands/releaseCommand/release.js

@@ -0,0 +1,88 @@
+const { bundleCodePush } = require("../bundleCommand/bundleCodePush");
+const { addToReleaseHistory } = require("./addToReleaseHistory");
+
+/**
+ * @param bundleUploader {
+ *   function(
+ *       source: string,
+ *       platform: "ios" | "android",
+ *       identifier?: string
+ *   ): Promise<{ downloadUrl: string }>}
+ * @param getReleaseHistory {
+ *   function(
+ *     targetBinaryVersion: string,
+ *     platform: "ios" | "android",
+ *     identifier?: string
+ *   ): Promise<ReleaseHistoryInterface>}
+ * @param setReleaseHistory {
+ *   function(
+ *     targetBinaryVersion: string,
+ *     jsonFilePath: string,
+ *     releaseInfo: ReleaseHistoryInterface,
+ *     platform: "ios" | "android",
+ *     identifier?: string
+ *   ): Promise<void>}
+ * @param binaryVersion {string}
+ * @param appVersion {string}
+ * @param platform {"ios" | "android"}
+ * @param identifier {string?}
+ * @param outputPath {string}
+ * @param entryFile {string}
+ * @param jsBundleName {string}
+ * @param mandatory {boolean}
+ * @param enable {boolean}
+ * @return {Promise<void>}
+ */
+async function release(
+    bundleUploader,
+    getReleaseHistory,
+    setReleaseHistory,
+    binaryVersion,
+    appVersion,
+    platform,
+    identifier,
+    outputPath,
+    entryFile,
+    jsBundleName,
+    mandatory,
+    enable,
+) {
+    const { bundleFileName, packageHash } = await bundleCodePush(
+        platform,
+        outputPath,
+        entryFile,
+        jsBundleName,
+    );
+
+    const downloadUrl = await (async () => {
+        try {
+            const { downloadUrl } = await bundleUploader(`./${bundleFileName}`, platform, identifier);
+            return downloadUrl
+        } catch (error) {
+            console.error('Failed to upload the bundle file. Exiting the program.', error)
+            process.exit(1)
+        }
+    })();
+
+    await addToReleaseHistory(
+        appVersion,
+        binaryVersion,
+        downloadUrl,
+        packageHash,
+        getReleaseHistory,
+        setReleaseHistory,
+        platform,
+        identifier,
+        mandatory,
+        enable,
+    )
+
+    deleteUploadedBundleFile(bundleFileName);
+}
+
+function deleteUploadedBundleFile(bundleFileName) {
+    const fs = require('fs');
+    fs.unlinkSync(`./${bundleFileName}`);
+}
+
+module.exports = { release: release }

package/cli/commands/showHistoryCommand/index.js

@@ -0,0 +1,28 @@
+const { program, Option } = require("commander");
+const { findAndReadConfigFile } = require("../../utils/fsUtils");
+
+program.command('show-history')
+    .description('Retrieves and prints the release history of a specific binary version.\n`getReleaseHistory` function should be implemented in the config file.')
+    .requiredOption('-b, --binary-version <string>', '(Required) The target binary version for retrieving the release history.')
+    .addOption(new Option('-p, --platform <type>', 'platform').choices(['ios', 'android']).default('ios'))
+    .option('-i, --identifier <string>', 'reserved characters to distinguish the release.')
+    .option('-c, --config <path>', 'configuration file name (JS/TS)', 'code-push.config.ts')
+    /**
+     * @param {Object} options
+     * @param {string} options.binaryVersion
+     * @param {string} options.platform
+     * @param {string} options.identifier
+     * @param {string} options.config
+     * @return {void}
+     */
+    .action(async (options) => {
+        const config = findAndReadConfigFile(process.cwd(), options.config);
+
+        const releaseHistory = await config.getReleaseHistory(
+            options.binaryVersion,
+            options.platform,
+            options.identifier
+        );
+
+        console.log(JSON.stringify(releaseHistory, null, 2));
+    });

package/cli/commands/updateHistoryCommand/index.js

@@ -0,0 +1,49 @@
+const { program, Option } = require("commander");
+const { findAndReadConfigFile } = require("../../utils/fsUtils");
+const { updateReleaseHistory } = require("./updateReleaseHistory");
+
+program.command('update-history')
+    .description('Updates the release history for a specific binary version.\n`getReleaseHistory`, `setReleaseHistory` functions should be implemented in the config file.')
+    .requiredOption('-v, --app-version <string>', '(Required) The app version for which update information is to be modified.')
+    .requiredOption('-b, --binary-version <string>', '(Required) The target binary version of the app for which update information is to be modified.')
+    .addOption(new Option('-p, --platform <type>', 'platform').choices(['ios', 'android']).default('ios'))
+    .option('-i, --identifier <string>', 'reserved characters to distinguish the release.')
+    .option('-c, --config <path>', 'set config file name (JS/TS)', 'code-push.config.ts')
+    .option('-m, --mandatory <bool>', 'make the release to be mandatory', parseBoolean, undefined)
+    .option('-e, --enable <bool>', 'make the release to be enabled', parseBoolean, undefined)
+    /**
+     * @param {Object} options
+     * @param {string} options.appVersion
+     * @param {string} options.binaryVersion
+     * @param {string} options.platform
+     * @param {string} options.identifier
+     * @param {string} options.config
+     * @param {string} options.mandatory
+     * @param {string} options.enable
+     * @return {void}
+     */
+    .action(async (options) => {
+        const config = findAndReadConfigFile(process.cwd(), options.config);
+
+        if (typeof options.mandatory !== "boolean" && typeof options.enable !== "boolean") {
+            console.error('No options specified. Exiting the program.')
+            process.exit(1)
+        }
+
+        await updateReleaseHistory(
+            options.appVersion,
+            options.binaryVersion,
+            config.getReleaseHistory,
+            config.setReleaseHistory,
+            options.platform,
+            options.identifier,
+            options.mandatory,
+            options.enable,
+        )
+    });
+
+function parseBoolean(value) {
+    if (value === 'true') return true;
+    if (value === 'false') return false;
+    else return undefined;
+}