@bravemobile/react-native-code-push 8.3.1 → 9.0.0-alpha.1

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;
+}

package/cli/commands/updateHistoryCommand/updateReleaseHistory.js

@@ -0,0 +1,62 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ *
+ * @param appVersion {string}
+ * @param binaryVersion {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 updateReleaseHistory(
+    appVersion,
+    binaryVersion,
+    getReleaseHistory,
+    setReleaseHistory,
+    platform,
+    identifier,
+    mandatory,
+    enable,
+) {
+    const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
+
+    const updateInfo = releaseHistory[appVersion]
+    if (!updateInfo) throw new Error(`v${appVersion} is not released`)
+
+    if (typeof mandatory === "boolean") updateInfo.mandatory = mandatory;
+    if (typeof enable === "boolean") updateInfo.enabled = enable;
+
+    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(releaseHistory, null, 2));
+        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(releaseHistory));
+
+        await setReleaseHistory(binaryVersion, JSON_FILE_PATH, releaseHistory, platform, identifier)
+
+        fs.unlinkSync(JSON_FILE_PATH);
+    } catch (error) {
+        console.error('Error occurred while updating history:', error);
+        process.exit(1)
+    }
+}
+
+module.exports = { updateReleaseHistory: updateReleaseHistory }

package/cli/constant.js

@@ -0,0 +1,3 @@
+module.exports = {
+  configFileName: "code-push.config.ts",
+};

package/cli/functions/getReactTempDir.js

@@ -0,0 +1,16 @@
+/**
+ * code based on appcenter-cli
+ */
+
+const os = require('os');
+
+/**
+ * Return the path of the temporary directory for react-native bundling
+ *
+ * @return {string}
+ */
+function getReactTempDir() {
+    return `${os.tmpdir()}/react-*`;
+}
+
+module.exports = { getReactTempDir };

package/cli/functions/makeCodePushBundle.js

@@ -0,0 +1,27 @@
+const { randomUUID } = require('crypto');
+const path = require('path');
+const shell = require('shelljs');
+const zip = require('../utils/zip');
+const {generatePackageHashFromDirectory} = require('../utils/hash-utils');
+
+/**
+ * Create a CodePush bundle file and return the information.
+ *
+ * @param contentsPath {string} The directory path containing the contents to be made into a CodePush bundle (usually the 'build/CodePush' directory))
+ * @return {Promise<{ bundleFileName: string, packageHash: string }>}
+ */
+async function makeCodePushBundle(contentsPath) {
+    const updateContentsZipPath = await zip(contentsPath);
+
+    const bundleFileName = randomUUID();
+    shell.mv(updateContentsZipPath, `./${bundleFileName}`);
+
+    const packageHash = await generatePackageHashFromDirectory(contentsPath, path.join(contentsPath, '..'));
+
+    return {
+        bundleFileName: bundleFileName,
+        packageHash: packageHash,
+    };
+}
+
+module.exports = { makeCodePushBundle };

package/cli/functions/prepareToBundleJS.js

@@ -0,0 +1,12 @@
+const shell = require('shelljs');
+
+/**
+ * @param deleteDirs {string[]} Directories to delete
+ * @param makeDir {string} Directory path to create
+ */
+function prepareToBundleJS({ deleteDirs, makeDir }) {
+    shell.rm('-rf', deleteDirs);
+    shell.mkdir('-p', makeDir);
+}
+
+module.exports = { prepareToBundleJS };

package/cli/functions/runHermesEmitBinaryCommand.js

@@ -0,0 +1,213 @@
+/**
+ * code based on appcenter-cli
+ */
+
+const childProcess = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const shell = require('shelljs');
+
+/**
+ * Run Hermes compile CLI command
+ *
+ * @param bundleName {string} JS bundle file name
+ * @param outputPath {string} Path to output .hbc file
+ * @param sourcemapOutput {string} Path to output sourcemap file (Warning: if sourcemapOutput points to the outputPath, the sourcemap will be included in the CodePush bundle and increase the deployment size)
+ * @param extraHermesFlags {string[]} Additional options to pass to `hermesc` command
+ * @return {Promise<void>}
+ */
+async function runHermesEmitBinaryCommand(
+    bundleName,
+    outputPath,
+    sourcemapOutput,
+    extraHermesFlags = [],
+) {
+    /**
+     * @type {string[]}
+     */
+    const hermesArgs = [
+        '-emit-binary',
+        '-out',
+        path.join(outputPath, bundleName + '.hbc'),
+        path.join(outputPath, bundleName),
+        ...extraHermesFlags,
+    ];
+    if (sourcemapOutput) {
+        hermesArgs.push('-output-source-map');
+    }
+
+    console.log('Converting JS bundle to byte code via Hermes, running command:\n');
+
+    return new Promise((resolve, reject) => {
+        try {
+            const hermesCommand = getHermesCommand();
+
+            const disableAllWarningsArg = '-w';
+            shell.exec(`${hermesCommand} ${hermesArgs.join(' ')} ${disableAllWarningsArg}`);
+
+            // Copy HBC bundle to overwrite JS bundle
+            const source = path.join(outputPath, bundleName + '.hbc');
+            const destination = path.join(outputPath, bundleName);
+            shell.cp(source, destination);
+            shell.rm(source);
+            resolve();
+        } catch (e) {
+            reject(e);
+        }
+    }).then(() => {
+        if (!sourcemapOutput) {
+            // skip source map compose if source map is not enabled
+            return;
+        }
+
+        // compose-source-maps.js file path
+        const composeSourceMapsPath = getComposeSourceMapsPath();
+        if (composeSourceMapsPath === null) {
+            throw new Error('react-native compose-source-maps.js scripts is not found');
+        }
+
+        const jsCompilerSourceMapFile = path.join(outputPath, bundleName + '.hbc' + '.map');
+        if (!fs.existsSync(jsCompilerSourceMapFile)) {
+            throw new Error(`sourcemap file ${jsCompilerSourceMapFile} is not found`);
+        }
+
+        return new Promise((resolve, reject) => {
+            const composeSourceMapsArgs = [
+                composeSourceMapsPath,
+                sourcemapOutput,
+                jsCompilerSourceMapFile,
+                '-o',
+                sourcemapOutput,
+            ];
+            const composeSourceMapsProcess = childProcess.spawn('node', composeSourceMapsArgs);
+            console.log(`${composeSourceMapsPath} ${composeSourceMapsArgs.join(' ')}`);
+
+            composeSourceMapsProcess.stdout.on('data', (data) => {
+                console.log(data.toString().trim());
+            });
+
+            composeSourceMapsProcess.stderr.on('data', (data) => {
+                console.error(data.toString().trim());
+            });
+
+            composeSourceMapsProcess.on('close', (exitCode, signal) => {
+                if (exitCode !== 0) {
+                    reject(new Error(`"compose-source-maps" command failed (exitCode=${exitCode}, signal=${signal}).`));
+                }
+
+                // Delete the HBC sourceMap, otherwise it will be included in 'code-push' bundle as well
+                fs.unlink(jsCompilerSourceMapFile, (err) => {
+                    if (err != null) {
+                        console.error(err);
+                        reject(err);
+                    }
+
+                    resolve();
+                });
+            });
+        });
+    });
+}
+
+/**
+ * @return {string}
+ */
+function getHermesCommand() {
+    /**
+     * @type {(file: string) => boolean}
+     */
+    const fileExists = (file) => {
+        try {
+            return fs.statSync(file).isFile();
+        } catch (e) {
+            return false;
+        }
+    };
+    // Hermes is bundled with react-native since 0.69
+    const bundledHermesEngine = path.join(
+        getReactNativePackagePath(),
+        'sdks',
+        'hermesc',
+        getHermesOSBin(),
+        getHermesOSExe(),
+    );
+    if (fileExists(bundledHermesEngine)) {
+        return bundledHermesEngine;
+    }
+    throw new Error('Hermes engine binary not found. Please upgrade to react-native 0.69 or later');
+}
+
+/**
+ * @return {string}
+ */
+function getHermesOSBin() {
+    switch (process.platform) {
+        case 'win32':
+            return 'win64-bin';
+        case 'darwin':
+            return 'osx-bin';
+        case 'freebsd':
+        case 'linux':
+        case 'sunos':
+        default:
+            return 'linux64-bin';
+    }
+}
+
+/**
+ * @return {string}
+ */
+function getHermesOSExe() {
+    const hermesExecutableName = 'hermesc';
+    switch (process.platform) {
+        case 'win32':
+            return hermesExecutableName + '.exe';
+        default:
+            return hermesExecutableName;
+    }
+}
+
+/**
+ * @return {string | null}
+ */
+function getComposeSourceMapsPath() {
+    // detect if compose-source-maps.js script exists
+    const composeSourceMaps = path.join(getReactNativePackagePath(), 'scripts', 'compose-source-maps.js');
+    if (fs.existsSync(composeSourceMaps)) {
+        return composeSourceMaps;
+    }
+    return null;
+}
+
+/**
+ * @return {string}
+ */
+function getReactNativePackagePath() {
+    const result = childProcess.spawnSync('node', [
+        '--print',
+        "require.resolve('react-native/package.json')",
+    ]);
+    const packagePath = path.dirname(result.stdout.toString());
+    if (result.status === 0 && directoryExistsSync(packagePath)) {
+        return packagePath;
+    }
+
+    return path.join('node_modules', 'react-native');
+}
+
+/**
+ * @param dirname {string}
+ * @return {boolean}
+ */
+function directoryExistsSync(dirname) {
+    try {
+        return fs.statSync(dirname).isDirectory();
+    } catch (err) {
+        if (err.code !== 'ENOENT') {
+            throw err;
+        }
+    }
+    return false;
+}
+
+module.exports = { runHermesEmitBinaryCommand };

package/cli/functions/runReactNativeBundleCommand.js

@@ -0,0 +1,59 @@
+/**
+ * code based on appcenter-cli
+ */
+
+const path = require('path');
+const shell = require('shelljs');
+
+/**
+ * Run `react-native bundle` CLI command
+ *
+ * @param bundleName {string} JS bundle file name
+ * @param entryFile {string} App code entry file name (default: index.ts)
+ * @param outputPath {string} Path to output JS bundle file and assets
+ * @param platform {string} Platform (ios | android)
+ * @param sourcemapOutput {string} Path to output sourcemap file (Warning: if sourcemapOutput points to the outputPath, the sourcemap will be included in the CodePush bundle and increase the deployment size)
+ * @param extraBundlerOptions {string[]} Additional options to pass to `react-native bundle` command
+ * @return {void}
+ */
+function runReactNativeBundleCommand(
+    bundleName,
+    outputPath,
+    platform,
+    sourcemapOutput,
+    entryFile = 'index.ts',
+    extraBundlerOptions = [],
+) {
+    /**
+     * @return {string}
+     */
+    function getCliPath() {
+        return path.join('node_modules', '.bin', 'react-native');
+    }
+
+    /**
+     * @type {string[]}
+     */
+    const reactNativeBundleArgs = [
+        'bundle',
+        '--assets-dest',
+        outputPath,
+        '--bundle-output',
+        path.join(outputPath, bundleName),
+        '--dev',
+        'false',
+        '--entry-file',
+        entryFile,
+        '--platform',
+        platform,
+        '--sourcemap-output',
+        sourcemapOutput,
+        ...extraBundlerOptions,
+    ];
+
+    console.log('Running "react-native bundle" command:\n');
+
+    shell.exec(`${getCliPath()} ${reactNativeBundleArgs.join(' ')}`);
+}
+
+module.exports = { runReactNativeBundleCommand };

package/cli/index.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+const { program } = require("commander");
+const shell = require("shelljs");
+const { showLogo } = require("./utils/showLogo");
+
+shell.set("-e");
+shell.set("+v");
+
+program
+  .name("npx code-push")
+  .description("Command line interface for @bravemobile/react-native-code-push")
+  .version("1.0.0")
+  .action(() => {
+    showLogo();
+  });
+
+/**
+ * npx code-push bundle
+ */
+require("./commands/bundleCommand");
+
+/**
+ * npx code-push create-history
+ */
+require('./commands/createHistoryCommand');
+
+/**
+ * npx code-push update-history
+ */
+require('./commands/updateHistoryCommand');
+
+/**
+ * npx code-push release
+ */
+require('./commands/releaseCommand');
+
+/**
+ * npx code-push show-history
+ */
+require('./commands/showHistoryCommand')
+
+program.parse();