@algocare/react-native-code-push 9.0.0-beta.3

package/cli/commands/showHistoryCommand/index.js

@@ -0,0 +1,29 @@
+const { program, Option } = require("commander");
+const { findAndReadConfigFile } = require("../../utils/fsUtils");
+const { CONFIG_FILE_NAME } = require('../../constant');
+
+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)', CONFIG_FILE_NAME)
+    /**
+     * @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,50 @@
+const { program, Option } = require("commander");
+const { findAndReadConfigFile } = require("../../utils/fsUtils");
+const { updateReleaseHistory } = require("./updateReleaseHistory");
+const { CONFIG_FILE_NAME } = require('../../constant');
+
+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)', CONFIG_FILE_NAME)
+    .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,6 @@
+module.exports = {
+  CONFIG_FILE_NAME: "code-push.config.ts",
+  OUTPUT_BUNDLE_DIR: "bundleOutput",
+  ROOT_OUTPUT_DIR: "build",
+  ENTRY_FILE: "index.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,28 @@
+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))
+ * @param bundleDirectory {string} The directory path to save the CodePush bundle file
+ * @return {Promise<{ bundleFileName: string }>}
+ */
+async function makeCodePushBundle(contentsPath, bundleDirectory) {
+    const updateContentsZipPath = await zip(contentsPath);
+
+    const packageHash = await generatePackageHashFromDirectory(contentsPath, path.join(contentsPath, '..'));
+
+    shell.mkdir('-p', `./${bundleDirectory}`);
+    shell.mv(updateContentsZipPath, `./${bundleDirectory}/${packageHash}`);
+
+    return {
+        // To allow the "release" command to get the file and hash value from the result of the "bundle" command,
+        // use the hash value as the name of the file.
+        bundleFileName: 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,
+    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 @algocare/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()

package/cli/utils/file-utils.js

@@ -0,0 +1,42 @@
+/**
+ * code based on appcenter-cli
+ */
+
+const fs = require('fs');
+
+/**
+ *
+ * @param path {string}
+ * @return {boolean}
+ */
+function isDirectory(path) {
+    return fs.statSync(path).isDirectory();
+}
+
+/**
+ *
+ * @param length {number}
+ * @return {string}
+ */
+function generateRandomFilename(length) {
+    let filename = '';
+    const validChar = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+
+    for (let i = 0; i < length; i++) {
+        filename += validChar.charAt(Math.floor(Math.random() * validChar.length));
+    }
+
+    return filename;
+}
+
+/**
+ *
+ * @param filePath {string}
+ * @return {string}
+ */
+function normalizePath(filePath) {
+    //replace all backslashes coming from cli running on windows machines by slashes
+    return filePath.replace(/\\/g, '/');
+}
+
+module.exports = { isDirectory, generateRandomFilename, normalizePath };

package/cli/utils/fsUtils.js

@@ -0,0 +1,49 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * allows to require a config file with .ts extension
+ * @param filePath {string}
+ * @returns {*} FIXME type
+ */
+function requireConfig(filePath) {
+  const ext = path.extname(filePath);
+
+  if (ext === '.ts') {
+    try {
+      require('ts-node/register');
+    } catch {
+      console.error('ts-node not found. Please install ts-node as a devDependency.');
+      process.exit(1);
+    }
+  } else if (ext === '.js') {
+    // do nothing
+  } else {
+    throw new Error(`Unsupported file extension: ${ext}`);
+  }
+
+  return require(filePath);
+}
+
+/**
+ * @param startDir {string}
+ * @param configFileName {string}
+ * @returns {*|null} FIXME type
+ */
+function findAndReadConfigFile(startDir, configFileName) {
+  let dir = startDir;
+
+  while (dir !== path.parse(dir).root) {
+    const configPath = path.join(dir, configFileName);
+    if (fs.existsSync(configPath)) {
+      const config = requireConfig(configPath);
+      return config;
+    }
+    dir = path.dirname(dir);
+  }
+
+  console.error(`${configFileName} not found.`);
+  return null;
+}
+
+module.exports = { findAndReadConfigFile };