@wavemaker-ai/wm-reactnative-cli 1.0.0

package/src/command.js

@@ -0,0 +1,552 @@
+const fs = require('fs-extra');
+const logger = require('./logger');
+const plist = require('plist');
+const path = require('path');
+const android = require('./android');
+const { unzip } = require('./zip');
+let { showConfirmation,VERSIONS, 
+    canDoAndroidBuild, canDoIosBuild, canDoEmbed 
+} = require('./requirements');
+
+const {
+    exec
+} = require('./exec');
+
+const crypto = require('crypto');
+const config = require('./config');
+const ios = require('./ios');
+const { resolve } = require('path');
+const { isWindowsOS, readAndReplaceFileContent, getDestPathForWindows, updateIsAiPlatform } = require('./utils');
+const chalk = require('chalk');
+const taskLogger = require('./custom-logger/task-logger').spinnerBar;
+const loggerLabel = 'wm-reactnative-cli';
+const {androidBuildSteps} = require('./custom-logger/steps');
+
+function getFileSize(path) {
+    const stats = path && fs.statSync(path);
+    return (stats && stats['size']) || 0;
+}
+
+async function updatePackageJsonFile(path) {
+    try {
+        let data = fs.readFileSync(path, 'utf-8');
+        //downgrading expo-av to 11 to address the build failure issue
+        data = data.replace(/"expo-av"[\s]*:[\s]*"~13.0.1"/, '"expo-av": "~11.0.1"');
+        const jsonData = JSON.parse(data);
+        jsonData['main'] = "index";
+        if (config.embed) {
+            jsonData['dependencies']['@wavemaker/expo-native-module'] = "latest";
+        }
+        if(!jsonData['devDependencies']['@babel/plugin-proposal-optional-chaining']){
+            jsonData['devDependencies']['@babel/plugin-proposal-optional-chaining'] = "^7.21.0";
+        }
+        if(!jsonData['devDependencies']['@babel/plugin-proposal-nullish-coalescing-operator']){
+            jsonData['devDependencies']['@babel/plugin-proposal-nullish-coalescing-operator'] = "^7.18.6";
+        }
+        if (!jsonData['dependencies']['lottie-react-native']
+            || jsonData['dependencies']['lottie-react-native'] === '5.1.5') {
+            jsonData['dependencies']['lottie-react-native'] = "^5.1.5";
+            jsonData['dependencies']['react-lottie-player'] = "^1.5.4";
+        }
+        if (jsonData['dependencies']['expo-file-system'] === '^15.1.1') {
+            jsonData['dependencies']['expo-file-system'] = '15.2.2'
+        }
+        if (jsonData['dependencies']['axios'] === '^1.4.0') {
+            jsonData['dependencies']['axios'] = '1.6.8';
+        }
+        const resolutions = jsonData["resolutions"] || {};
+        if (!resolutions['expo-application']) {
+            resolutions['expo-application'] = '5.8.4';
+        }
+        if (!resolutions['axios']) {
+            resolutions['axios'] = '1.6.8';
+        }
+        if (jsonData['dependencies']['expo'] === '50.0.17') {
+            resolutions['metro'] = '0.80.9';
+        }
+        jsonData["resolutions"] = resolutions;
+        if (config.platform === 'android') {
+            jsonData['dependencies']['@react-native-cookies/cookies'] = '6.2.1';
+        }
+        fs.writeFileSync(path, JSON.stringify(jsonData), 'utf-8');
+        logger.info({
+            'label': loggerLabel,
+            'message': 'updated package.json file'
+        });
+    } catch (e) {
+        resolve('error', e);
+    }
+}
+
+ async function build(args) {
+    const directories = await setupBuildDirectory(args.src, args.dest, args.platform);
+    if (!directories) {
+        return {
+            success : false,
+            errors: 'could not setup the build directories.'
+        };
+    }
+    args.src = directories.src;
+    args.dest = directories.dest;
+ 
+    config.metaData = await readWmRNConfig(args.src);
+    const packageJsonData = await readPackageJson(args.src);
+
+    const deps = packageJsonData.dependencies || {};
+    const is_ai_platform = Boolean(
+        deps['@wavemaker-ai/rn-codegen'] ||
+        deps['@wavemaker-ai/app-rn-runtime']
+    );
+    updateIsAiPlatform(is_ai_platform);
+
+    if (config.metaData.icon.src.startsWith('resources')) {
+        config.metaData.icon.src = 'assets/' + config.metaData.icon.src;
+    }
+    if (config.metaData.splash.src?.startsWith('resources')) {
+        config.metaData.splash.src = 'assets/' + config.metaData.splash.src;
+    }
+
+     config.platform = args.platform;
+     
+     if (args.dest) {
+        args.dest = path.resolve(args.dest) + '/';
+     }
+    taskLogger.succeed(androidBuildSteps[0].succeed);
+
+    await prepareProject(args);
+    if (args.targetPhase === 'PREPARE')
+    {
+        return;
+    }
+    if (!args.autoEject) {
+        const response = await showConfirmation(
+            'Would you like to eject the expo project (yes/no) ?'
+        );
+        if (response !== 'y' && response !== 'yes') {
+            process.exit();
+        }
+    }
+
+    let response;
+    if (args.dest) {
+        if (!config.metaData.ejected) {
+            response = await ejectProject(args);
+        }
+    } else {
+        response = await ejectProject(args);
+    }
+
+    if (response && response.errors) {
+        return response;
+    }
+
+    if (args.ejectProject || config.embed)  {
+        return;
+    }
+
+    if (args.dest) {
+        config.src = args.dest;
+    }
+    // TODO: iOS app showing blank screen
+    if (!(config.metaData.sslPinning && config.metaData.sslPinning.enabled)) {
+        await readAndReplaceFileContent(`${config.src}/App.js`, content => {
+            return content.replace('if (isSslPinningAvailable()) {', 
+                'if (false && isSslPinningAvailable()) {');
+        });
+    }
+
+    if(args.architecture && args.platform==='android') {
+        await readAndReplaceFileContent(`${config.src}/android/gradle.properties`, content => {
+            return content.replace(/^reactNativeArchitectures=.*$/m,`reactNativeArchitectures=${args.architecture.join(',')}`);
+        })
+    }
+
+    config.outputDirectory = config.src + 'output/';
+    config.logDirectory = config.outputDirectory + 'logs/';
+    logger.info({
+        label: loggerLabel,
+        message: `Building at : ${config.src}`
+    });
+
+    taskLogger.info(`Building at : ${config.src}`);
+
+    try {
+        let result;
+        // await clearUnusedAssets(config.platform);
+        if (config.platform === 'android') {
+            result = await android.invokeAndroidBuild(args);
+        } else if (config.platform === 'ios') {
+            try{
+                taskLogger.start("Installing pods....")
+                await exec('pod', ['install'], {
+                    cwd: config.src + 'ios'
+                });
+            }catch(e){
+                taskLogger.fail("Pod install failed");
+            }
+            result = await ios.invokeiosBuild(args);
+        }
+        if (result.errors && result.errors.length) {
+            logger.error({
+                label: loggerLabel,
+                message: args.platform + ' build failed due to: \n\t' + result.errors.join('\n\t')
+            });
+            taskLogger.fail(args.platform + ' build failed due to: \n\t' + result.errors.join('\n\t'));
+        } else if (!result.success) {
+            logger.error({
+                label: loggerLabel,
+                message: args.platform + ' BUILD FAILED'
+            });
+            taskLogger.fail(args.platform + ' BUILD FAILED');
+        } else {
+            logger.info({
+                label: loggerLabel,
+                message: `${args.platform} BUILD SUCCEEDED. check the file at : ${result.output}.`
+            });
+            taskLogger.info(`${args.platform} BUILD SUCCEEDED. check the file at : ${result.output}.`);
+            logger.info({
+                label: loggerLabel,
+                message: `File size : ${Math.round(getFileSize(result.output) * 100 / (1024 * 1024)) / 100} MB.`
+            });
+            taskLogger.info(`File size : ${Math.round(getFileSize(result.output) * 100 / (1024 * 1024)) / 100} MB.`);
+        }
+        return result;
+    } catch(e) {
+        logger.error({
+            label: loggerLabel,
+            message: 'BUILD Failed. Due to :' + e
+        });
+        taskLogger.fail('BUILD Failed. Due to :' + e);
+        return {
+            success : false,
+            errors: e
+         };
+    }
+}
+
+async function extractRNZip(src)  {
+    let folderName = isWindowsOS() ? src.split('\\').pop() : src.split('/').pop();
+    const isZipFile = folderName.endsWith('.zip');
+
+    folderName = isZipFile ? folderName.replace('.zip', '') : folderName;
+
+    const tmp = `${require('os').homedir()}/.wm-reactnative-cli/temp/${folderName}/${Date.now()}`;
+
+    if (src.endsWith('.zip')) {
+        const zipFile = src;
+        src = tmp + '/src';
+
+        if (!fs.existsSync(src)) {
+            fs.mkdirsSync(src);
+        }
+        await unzip(zipFile, src);
+    }
+    return path.resolve(src) + '/';
+}
+
+async function setupBuildDirectory(src, dest, platform) {
+    try{
+        taskLogger.setTotal(androidBuildSteps[0].total);
+        taskLogger.start(androidBuildSteps[0].start);
+        src = await extractRNZip(src);
+        taskLogger.incrementProgress(1);
+        const metadata = await readWmRNConfig(src);
+        taskLogger.incrementProgress(1);
+        if (fs.existsSync(dest)) {
+            if (fs.readdirSync(dest).length) {
+                const response = await showConfirmation('Would you like to empty the dest folder (i.e. ' + dest + ') (yes/no) ?');
+                if (response !== 'y' && response !== 'yes') {
+                    // logger.error({
+                    //     label: loggerLabel,
+                    //     message: 'Non empty folder cannot be used as desination. Please choose a different destination and build again.'
+                    // });
+                    // return;
+                }else{
+                    // using removeSync when dest is directory and unlinkSync works when dest is file.
+                    const fsStat = fs.lstatSync(dest);
+                    if (fsStat.isDirectory()) {
+                        fs.removeSync(dest);
+                    } else if (fsStat.isFile()) {
+                        fs.unlinkSync(dest);
+                    }   
+                }
+            }
+        }
+        taskLogger.incrementProgress(1);
+        dest = dest || await getDefaultDestination(metadata.id, platform);
+        if(isWindowsOS()){
+            dest = await getDestPathForWindows('build');
+        }
+        dest = path.resolve(dest)  + '/';
+        if(src === dest) {
+            logger.error({
+                label: loggerLabel,
+                message: 'source and destination folders are same. Please choose a different destination.'
+            });
+            taskLogger.fail('source and destination folders are same. Please choose a different destination.');
+            return;
+        }
+        taskLogger.incrementProgress(1);
+        fs.mkdirsSync(dest);
+        fs.copySync(src, dest);
+        taskLogger.incrementProgress(1);
+        const logDirectory = dest + 'output/logs/';
+        fs.mkdirSync(logDirectory, {
+            recursive: true
+        });
+        global.logDirectory = logDirectory;
+        logger.setLogDirectory(logDirectory);
+        taskLogger.info("Full log details can be found in: " + logDirectory);
+        return {
+            src: src,
+            dest: dest
+        };
+    }catch(e){
+        console.log(e.message);
+        taskLogger.fail("Setup directories failed. " + chalk.gray("Due to : ")  + chalk.cyan(e.message));
+    }
+}
+
+async function getDefaultDestination(id, platform) {
+    const version = '1.0.0';
+    const path = `${require('os').homedir()}/.wm-reactnative-cli/build/${id}/${version}/${platform}`;
+    fs.mkdirSync(path, {
+        recursive: true
+    });
+    let next = 1;
+    if (fs.existsSync(path)) {
+        next = fs.readdirSync(path).reduce((a, f) => {
+            try {
+                const c = parseInt(f);
+                if (a <= c) {
+                    return c + 1;
+                }
+            } catch(e) {
+                //not a number
+            }
+            return a;
+        }, next);
+    }
+    const dest = path + '/' + next;
+    fs.mkdirSync(dest, {
+        recursive: true
+    });
+    return dest;
+}
+
+async function readWmRNConfig(src) {
+    src = path.resolve(src) + '/';
+    let jsonPath = src + 'wm_rn_config.json';
+    let data = await fs.readFileSync(jsonPath);
+    data = JSON.parse(data);
+    data.preferences = data.preferences || {};
+    data.preferences.enableHermes = true;
+    return data;
+}
+
+async function readPackageJson(src){
+    src = path.resolve(src) + '/';
+    let packageJsonPath = src + 'package.json';
+    let data = await fs.readFileSync(packageJsonPath);
+    data = JSON.parse(data);
+    return data;
+}
+
+async function writeWmRNConfig(content) {
+    src = path.resolve(config.src) + '/';
+    let jsonPath = src + 'wm_rn_config.json';
+    let data = await fs.readFileSync(jsonPath);
+    data = JSON.parse(data);
+    if (content) {
+        Object.assign(data, content);
+    }
+    await fs.writeFile(jsonPath, JSON.stringify(data), error => {
+        if (error) {
+            throw error;
+        }
+        logger.info({
+            'label': loggerLabel,
+            'message': 'updated wm_rn_config.json file'
+        })
+    })
+}
+
+// src points to unzip proj
+async function ejectProject(args) {
+    try {
+        taskLogger.start(androidBuildSteps[3].start);
+        taskLogger.setTotal(androidBuildSteps[3].total);
+        taskLogger.incrementProgress(1);
+        if(args.platform){
+            await exec('npx', ['expo','prebuild', "--platform", args.platform], {
+                cwd: config.src
+            });
+        }else{
+            await exec('npx', ['expo','prebuild'], {
+                cwd: config.src
+            });
+        }
+        taskLogger.incrementProgress(1);
+        logger.info({
+            label: loggerLabel,
+            message: 'expo eject succeeded',
+        });
+        if (args.localrnruntimepath) {
+            const linkFolderPath =
+            config.src + `node_modules/${global.WM_REPO_SCOPE}/app-rn-runtime`;
+            // using removeSync when target is directory and unlinkSync works when target is file.
+            if (fs.existsSync(linkFolderPath)) {
+                fs.removeSync(linkFolderPath);
+            }
+            await fs.mkdirsSync(linkFolderPath);
+            await fs.copySync(args.localrnruntimepath, linkFolderPath);
+            logger.info({
+                label: loggerLabel,
+                message: 'copied the app-rn-runtime folder',
+            });
+            taskLogger.info("copied the app-rn-runtime folder");
+        }
+        taskLogger.succeed(androidBuildSteps[3].succeed);
+    } catch (e) {
+        logger.error({
+            label: loggerLabel,
+            message: args.platform + ' eject project Failed. Due to :' + e,
+        });
+        taskLogger.fail(androidBuildSteps[3].fail);
+        return { errors: e, success: false };
+    }
+}
+
+async function prepareProject(args) {
+    try {
+        taskLogger.setTotal(androidBuildSteps[1].total);
+        taskLogger.start(androidBuildSteps[1].start);
+        config.src = args.dest;
+        logger.info({
+            label: loggerLabel,
+            message: 'destination folder where app is build at ' + args.dest,
+        });
+        taskLogger.info('destination folder where app is build at ' + args.dest);
+        if (!args.platform) {
+            args.platform = 'android';
+        }
+        config.platform = args.platform;
+        config.buildType = args.buildType;
+
+        if (args.platform !== 'android') {
+            VERSIONS.JAVA = '1.8.0';
+        }
+        const prerequisiteError = {
+            errors: 'check if all prerequisites are installed.',
+            success: false
+        };
+        if (config.embed) {
+            if (!await canDoEmbed()) {
+                return prerequisiteError;
+            }
+        }
+        if (args.platform === 'android') {
+            if (!await canDoAndroidBuild()) {
+                return prerequisiteError;
+            }
+        }
+        if (args.platform === 'ios') {
+            if (!await canDoIosBuild()) {
+                return prerequisiteError;
+            }
+        }
+        taskLogger.incrementProgress(1);
+        taskLogger.succeed(androidBuildSteps[1].succeed);
+        taskLogger.setTotal(androidBuildSteps[2].total);
+        taskLogger.start(androidBuildSteps[2].start);
+        logger.info({
+            label: loggerLabel,
+            message: 'app.json updated.... ' + args.dest
+        })
+        taskLogger.incrementProgress(0.2);
+        try{
+            await exec('npm', ['install'], {
+                cwd: config.src
+            });
+            taskLogger.succeed("All dependencies installed successfully.")
+        }catch(e){
+            logger.error({
+                label: loggerLabel,
+                message: "Dependency installation failed. Due to : "+ e,
+            });
+            taskLogger.fail("Dependency installation failed. Due to : "+ e);
+        }
+    } catch (e) {
+        logger.error({
+            label: loggerLabel,
+            message: args.platform + ' prepare project Failed. Due to :' + e,
+        });
+        taskLogger.fail(args.platform + ' prepare project Failed. Due to :' + e);
+        return { errors: e, success : false };
+    }
+}
+
+async function clearUnusedAssets(platform) {
+    await readAndReplaceFileContent(config.src + 'app.theme.js', (content) => {
+        if (platform === 'ios') {
+            return content.replace(/ios:\s\{(.|\n)*?\},?/gm, ``);
+        }
+        return content.replace(/android:\s\{(.|\n)*?\},?/gm, ``);
+    });
+    logger.info({
+        'label': loggerLabel,
+        'message': '***** updated theme related files based on selected platform ...***'
+    });
+
+    const folderToExclude = platform === 'android' ? 'ios' : 'android';
+    const path = config.src + 'theme/' + folderToExclude;
+    if (fs.existsSync(path)) {
+        const fsStat = fs.lstatSync(path);
+        if (fsStat.isDirectory()) {
+            fs.removeSync(path);
+        } else if (fsStat.isFile()) {
+            fs.unlinkSync(path);
+        }
+        logger.info({
+            'label': loggerLabel,
+            'message': '***** Removed the unused platform theme folder ...***'
+        });
+    }
+}
+
+module.exports = {
+    ejectProject: (args) => {
+        args.autoEject = true;
+        args.ejectProject = true;
+        args.platform === 'expo'
+        build(args);
+    },
+    embed: async (args) => {
+        args.autoEject = true;
+        config.embed = true;
+        await build(args);
+        if (args.platform === 'android') {
+            await android.embed(args);
+            logger.info({
+                label: loggerLabel,
+                message: `Build Success. Check the embedded project at : ${args.dest}android-embed.`
+            });
+        } else if (args.platform === 'ios') {
+            await ios.embed(args);
+            logger.info({
+                label: loggerLabel,
+                message: `Build Success. Check the embedded project at : ${args.dest}ios-embed.`
+            });
+        }
+    },
+    build: build,
+    prepareProject: async (args) => {
+        args.targetPhase = 'PREPARE';
+        args.platform= 'expo';
+        await build(args);
+        logger.info({
+            label: loggerLabel,
+            message: `Project is prepared at : ${args.dest}.`,
+        });
+    },
+};

package/src/config.js

@@ -0,0 +1,11 @@
+const path = require('path');
+const fs = require('fs-extra');
+
+module.exports = {
+    src: '',
+    buildType: '',
+    logDirectory: '',
+    outputDirectory: '',
+    metaData: {},
+    embed: false
+};

package/src/custom-logger/progress-bar.js

@@ -0,0 +1,97 @@
+const chalk = require('chalk');
+const readline = require("readline");
+
+class ProgressBar {
+    constructor(options = {}) {
+        this.showProgressBar = options.showProgressBar || false;
+        this.barCompleteChar = options.barCompleteChar || '█';
+        this.barIncompleteChar = options.barIncompleteChar || '░';
+        this.barWidth = options.barWidth || 20;
+        this.barFormat = options.barFormat || '[{bar}] {percentage}%';
+        this.total = options.total || 100;
+        this.value = 0;
+        this.startTime = null;
+        
+        // Optional color configurations
+        this.completeColor = options.completeColor || null;
+        this.incompleteColor = options.incompleteColor || null;
+        this.textColor = options.textColor || null;
+    }
+
+    start() {
+        this.startTime = Date.now();
+    }
+
+    setProgress(value) {
+        this.value = Math.min(Math.max(0, value), this.total);
+    }
+
+    incrementProgress(amount = 1) {
+        this.setProgress(this.value + amount);
+    }
+
+    setTotal(total) {
+        this.total = total;
+    }
+
+    enable() {
+        this.showProgressBar = true;
+    }
+
+    disable() {
+        this.showProgressBar = false;
+    }
+
+    status() {
+        return this.showProgressBar;
+    }
+
+    calculateETA() {
+        if (!this.startTime || this.value === 0) return '?';
+        const elapsedTime = (Date.now() - this.startTime) / 1000;
+        const itemsPerSecond = this.value / elapsedTime;
+        const eta = Math.round((this.total - this.value) / itemsPerSecond);
+        return isFinite(eta) ? eta : '?';
+    }
+
+    render() {
+        if (!this.showProgressBar) return '';
+        const percentage = Math.floor((this.value / this.total) * 100);
+        const completeLength = Math.round((this.value / this.total) * this.barWidth);
+        const incompleteLength = this.barWidth - completeLength;
+        
+        let completeBar = this.barCompleteChar.repeat(completeLength);
+        let incompleteBar = this.barIncompleteChar.repeat(incompleteLength);
+        
+        if (this.completeColor) completeBar = chalk[this.completeColor](completeBar);
+        if (this.incompleteColor) incompleteBar = chalk[this.incompleteColor](incompleteBar);
+        
+        let bar = completeBar + incompleteBar;
+        let formattedText = this.barFormat
+            .replace('{bar}', bar)
+            .replace('{percentage}', percentage)
+            .replace('{value}', this.value)
+            .replace('{total}', this.total)
+            .replace('{eta}', this.calculateETA());
+        
+        if (this.textColor){ 
+            formattedText = chalk[this.textColor](formattedText);
+        }
+        readline.cursorTo(process.stdout, 0);
+
+        return formattedText;
+    }
+}
+
+const overallProgressBar = new ProgressBar({
+    showProgressBar: true,
+    barWidth: 40,
+    completeColor: 'green',
+    incompleteColor: 'gray',
+    textColor: 'cyan'
+});
+
+module.exports = {
+    ProgressBar,
+    overallProgressBar
+};