@wavemaker-ai/wm-reactnative-cli 1.0.0

package/src/project-sync.service.js

@@ -0,0 +1,390 @@
+const { URL } = require('url');
+const fs = require('fs-extra');
+const path = require('path');
+const logger = require('./logger');
+const prompt = require('prompt');
+const axios = require('axios');
+const os = require('os');
+const qs = require('qs');
+const semver = require('semver');
+const { exec } = require('./exec');
+const { unzip } = require('./zip');
+const taskLogger = require('./custom-logger/task-logger').spinnerBar;
+const {previewSteps} = require('./custom-logger/steps');
+const chalk = require('chalk');
+const { updateIsAiPlatform } = require('./utils');
+//const PULL_URL = '/studio/services/projects/${projectId}/vcs/remoteChanges';
+const STORE_KEY = 'user.auth.token';
+const MAX_REQUEST_ALLOWED_TIME = 5 * 60 * 1000;
+const loggerLabel = 'project-sync-service';
+let remoteBaseCommitId = '';
+let WM_PLATFORM_VERSION = '';
+
+async function findProjectId(config) {
+    const projectList = (await axios.get(`${config.baseUrl}/edn-services/rest/users/projects/list`,
+        {headers: {
+            cookie: config.authCookie
+        }})).data;
+    const project = projectList.filter(p => p.displayName === config.projectName)
+        .filter(p => (config.appPreviewUrl.endsWith(p.name + "_" + p.vcsBranchId)));
+    if (project && project.length) {
+        WM_PLATFORM_VERSION = project[0].platformVersion;
+        const is_ai_platform = /\.wavemaker\.ai/.test(config.baseUrl);
+        updateIsAiPlatform(is_ai_platform);
+        return project[0].studioProjectId;
+    }
+}
+
+async function downloadFile(res, tempFile){
+    if (res.status !== 200) {
+        throw new Error('failed to download the project');
+    }
+    await new Promise((resolve, reject) => {
+        const fw = fs.createWriteStream(tempFile);
+        res.data.pipe(fw);
+        fw.on('error', err => {
+            reject(err);
+            fw.close();
+        });
+        fw.on('close', resolve);
+    });
+}
+
+async function downloadProject(projectId, config, projectDir) {
+    try {
+    const start = Date.now();
+    logger.info({label: loggerLabel,message: 'downloading the project...'});
+    taskLogger.start(previewSteps[2].start);
+    taskLogger.setTotal(previewSteps[2].total)
+    const tempFile = `${os.tmpdir()}/changes_${Date.now()}.zip`;
+    if (semver.lt(WM_PLATFORM_VERSION, '11.4.0') && !global.IS_AI_PLATFORM) {
+        const res = await axios.get(`${config.baseUrl}/studio/services/projects/${projectId}/vcs/gitInit`, {
+            responseType: 'stream',
+            headers: {
+                cookie: config.authCookie
+            }
+         });
+        taskLogger.incrementProgress(2);
+        await downloadFile(res, tempFile);
+        taskLogger.incrementProgress(1);
+        const gitDir = path.join(projectDir, '.git');
+        fs.mkdirpSync(gitDir);
+        await unzip(tempFile, gitDir);
+        await exec('git', ['restore', '.'], {cwd: projectDir});
+        taskLogger.incrementProgress(1);
+    }
+    else{
+        const gitInfo = await axios.get(`${config.baseUrl}/studio/services/projects/${projectId}/vcs/gitBare`, {
+            responseType: 'application/json',
+            headers: {
+                cookie: config.authCookie
+            }
+         });
+         taskLogger.incrementProgress(2);
+        if(gitInfo.status !== 200){
+            throw new Error('failed to download the project');
+        }
+        const fileId = gitInfo.data.fileId;
+        remoteBaseCommitId = gitInfo.data.remoteBaseCommitId;
+        const res = await axios.get(`${config.baseUrl}/file-service/${fileId}`, {
+            responseType: 'stream',
+            headers: {
+                cookie: config.authCookie
+            }
+        })
+        taskLogger.incrementProgress(2);
+        await downloadFile(res, tempFile);
+        const tempDir = path.join(`${os.tmpdir()}`, `project_${Date.now()}`);
+        fs.mkdirpSync(tempDir);
+        const gitDir = path.join(projectDir, '.git');
+        if(fs.existsSync(gitDir)){
+            await unzip(tempFile, gitDir);
+            await exec('git', ['config', '--local', '--unset', 'core.bare'], {cwd: projectDir});
+            await exec('git', ['restore', '.'], {cwd: projectDir});
+        }
+        else{
+            await unzip(tempFile, tempDir);
+            fs.rmSync(projectDir, { recursive: true, force: true });
+            await exec('git', ['clone', "-b", "master", tempDir, projectDir]);
+        }
+        fs.rmSync(tempDir, { recursive: true, force: true });
+        taskLogger.incrementProgress(1);
+    }
+    logger.info({
+        label: loggerLabel,
+        message: `downloaded the project in (${Date.now() - start} ms).`
+    });
+    taskLogger.incrementProgress(1);
+    taskLogger.succeed(`${previewSteps[2].succeed} in (${Date.now() - start} ms).`);
+    fs.unlink(tempFile);
+        
+    const logDirectory = projectDir + '/output/logs/';
+    fs.mkdirSync(logDirectory, {
+        recursive: true
+    });
+    logger.info({
+        label: loggerLabel,
+        message: 'log directory = '+ logDirectory
+    });
+    global.logDirectory = logDirectory;
+    logger.setLogDirectory(logDirectory);
+    taskLogger.info("Full log details can be found in: " + chalk.blue(logDirectory));
+    } catch (e) {
+        logger.info({
+            label: loggerLabel,
+            message: e+` The download of the project has encountered an issue. Please ensure that the preview is active.`
+        });
+        taskLogger.fail(e+` ${previewSteps[2].fail}`)
+    }
+}
+
+async function gitResetAndPull(tempDir, projectDir){
+    await exec('git', ['clean', '-fd', '-e', 'output'], {cwd: projectDir});
+    await exec('git', ['fetch', path.join(tempDir, 'remoteChanges.bundle'), 'refs/heads/master'], {cwd: projectDir});
+    await exec('git', ['reset', '--hard', 'FETCH_HEAD'], {cwd: projectDir});
+}
+
+async function pullChanges(projectId, config, projectDir) {
+    try {
+    const output = await exec('git', ['rev-parse', 'HEAD'], {
+        cwd: projectDir
+    });
+    const headCommitId = output[0];
+    logger.debug({label: loggerLabel, message: 'HEAD commit id is ' + headCommitId});
+    taskLogger.start('pulling new changes from studio...');
+    const tempDir = path.join(`${os.tmpdir()}`, `changes_${Date.now()}`);
+    if (semver.lt(WM_PLATFORM_VERSION, '11.4.0') && !global.IS_AI_PLATFORM) {
+        const tempFile = `${os.tmpdir()}/changes_${Date.now()}.zip`;
+        console.log(tempFile);
+        const res = await axios.get(`${config.baseUrl}/studio/services/projects/${projectId}/vcs/remoteChanges?headCommitId=${headCommitId}`, {
+            responseType: 'stream',
+            headers: {
+                cookie: config.authCookie
+            }
+        });
+        await downloadFile(res, tempFile);
+        fs.mkdirpSync(tempDir);
+        await unzip(tempFile, tempDir);
+    
+        await gitResetAndPull(tempDir, projectDir);
+        await exec('git', ['apply', '--allow-empty', '--ignore-space-change', path.join(tempDir, 'patchFile.patch')], {cwd: projectDir});
+        logger.debug({label: loggerLabel, message: 'Copying any uncommitted binary files'});
+        copyContentsRecursiveSync(path.join(tempDir, 'binaryFiles'), projectDir);    
+        fs.unlink(tempFile);
+    }
+    else{
+        const gitInfo = await axios.get(`${config.baseUrl}/studio/services/projects/${projectId}/vcs/pull?lastPulledWorkspaceCommitId=${headCommitId}&lastPulledRemoteHeadCommitId=${remoteBaseCommitId}`, {
+            responseType: 'application/json',
+            headers: {
+                cookie: config.authCookie
+            }
+        });
+        if (gitInfo.status !== 200) {
+            throw new Error('failed to pull project changes');
+        }
+        const fileId = gitInfo.data.fileId;
+        remoteBaseCommitId = gitInfo.data.remoteBaseCommitId;
+        const res = await axios.get(`${config.baseUrl}/file-service/${fileId}`, {
+            responseType: 'stream',
+            headers: {
+                cookie: config.authCookie
+            }
+        })
+        fs.mkdirpSync(tempDir);
+        const tempFile = `${tempDir}/remoteChanges.bundle`;
+        await downloadFile(res, tempFile);
+        await gitResetAndPull(tempDir, projectDir);
+        fs.unlink(tempFile);
+    }
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    taskLogger.succeed(`pulled new changes from studio - head commit id ${headCommitId}`);
+    let filesChanged = await exec('git', ['diff','--name-status', 'HEAD~1', 'HEAD'], {cwd: projectDir});
+    filesChanged = filesChanged.filter(Boolean);
+    const changes = filesChanged.map((line) => {
+      const [status, ...fileParts] = line.trim().split(/\s+/);
+      const filePath = fileParts.join(' ').replace(/^.*webapp\//, '');
+      return { status, filePath };
+    });
+  
+    const formatted = changes.map(({ status, filePath }) => {
+        const color = status === 'A' ? chalk.green
+                    : status === 'D' ? chalk.red
+                    : status === 'M' ? chalk.yellow
+                    : chalk.cyan;
+    
+        return `${color(status)}:${color(filePath)}`;
+      });
+      taskLogger.info("Files changed: \n\t" + formatted.join('\n\t'));
+    } catch (e) {
+        logger.info({
+            label: loggerLabel,
+            message: e+` The attempt to execute "git pull" was unsuccessful. Please verify your connections.`
+        });
+        taskLogger.succeed( e+` The attempt to execute "git pull" was unsuccessful. Please verify your connections.`);
+    }
+}
+
+function copyContentsRecursiveSync(src, dest) {
+  fs.readdirSync(src).forEach(function(file) {
+      var childSrc = path.join(src, file);
+      var childDest = path.join(dest, file);
+      var exists = fs.existsSync(childSrc);
+      var stats = exists && fs.statSync(childSrc);
+      var isDirectory = exists && stats.isDirectory();
+      if (isDirectory) {
+          if (!fs.existsSync(childDest)) {
+              fs.mkdirSync(childDest);
+          }
+          copyContentsRecursiveSync(childSrc, childDest);
+      } else {
+	fs.copyFileSync(childSrc, childDest);
+      }
+  });
+}
+
+function extractAuthCookie(res) {
+    const headers = res && res.response && res.response.headers;
+    if (!headers) {
+        return;
+    }
+    const result = headers['set-cookie'].filter(s => s.indexOf('auth_cookie') >= 0);
+    if (result.length) {
+        return result[0].split(';')[0];
+    }
+}
+
+async function authenticateWithUserNameAndPassword(config) {
+    const credentials = await getUserCredentials();
+    return axios.post(`${config.baseUrl}/login/authenticate`, 
+        qs.stringify({
+            j_username: credentials.username,
+            j_password: credentials.password
+        }), {
+            maxRedirects: 0
+    }).catch((res) => {
+        const cookie = extractAuthCookie(res);
+        if (!cookie) {
+            console.log('Not able to login. Try again.');
+            return authenticate(config);
+        }
+        return cookie;
+    });
+}
+
+async function authenticateWithToken(config, showHelp) {
+    try {
+    if (showHelp) {
+        console.log('***************************************************************************************');
+        console.log('* Please open the below url in the browser, where your WaveMaker studio is opened.    *');
+        console.log('* Copy the response content and paste in the terminal.                                *');
+        console.log('***************************************************************************************');
+        console.log(`\n\n`);
+        console.log(`${config.baseUrl}/studio/services/auth/token`);
+        console.log(`\n\n`);
+    }
+    const cookie = (await getAuthToken()).token.split(';')[0];
+    if (!cookie) {
+        console.log('Not able to login. Try again.');
+        return authenticateWithToken(config);
+    }
+    return 'auth_cookie='+cookie;
+    } catch (e) {
+        logger.info({
+            label: loggerLabel,
+            message: e+` Your authentication has failed. Please proceed with a valid token.`
+        });
+    }
+}
+
+function getUserCredentials() {
+    var schema = {
+        properties: {
+            username: {
+                required: true
+            },
+            password: {
+                required: true,
+                hidden: true
+            }
+        }
+      };
+    prompt.start();
+    return new Promise((resolve, reject) => {
+        prompt.get(schema, (err, result) => {
+            if (err) {
+                reject(err);
+            } else {
+                resolve(result);
+            }
+        });
+    });
+}
+
+function getAuthToken() {
+    var schema = {
+        properties: {
+            token: {
+                required: true
+            }
+        }
+      };
+    prompt.start();
+    return new Promise((resolve, reject) => {
+        prompt.get(schema, (err, result) => {
+            if (err) {
+                reject(err);
+            } else {
+                resolve(result);
+            }
+        });
+    });
+}
+
+async function checkAuthCookie(config) {
+    try {
+        await findProjectId(config);
+        logger.info({
+            label: loggerLabel,
+            message: `user authenticated.`
+        });
+    } catch(e) {
+        return false;
+    }
+    return true;
+}
+
+async function setup(previewUrl, projectName, authToken) {
+    if (authToken) {
+        authToken = 'auth_cookie=' + authToken;
+    }
+    if (previewUrl.endsWith('/')) {
+        previewUrl = previewUrl.slice(0, -1);
+    }
+    const config = {
+        authCookie : authToken || global.localStorage.getItem(STORE_KEY) || '',
+        baseUrl: new URL(previewUrl).origin,
+        appPreviewUrl: previewUrl,
+        projectName: projectName
+    };
+    const isAuthenticated = await checkAuthCookie(config);
+    if (!isAuthenticated) {
+        //console.log(`Need to login to Studio (${config.baseUrl}). \n Please enter your Studio credentails.`);
+        //config.authCookie = await authenticateWithUserNameAndPassword(config);
+        config.authCookie = await authenticateWithToken(config, true);
+    }
+    global.localStorage.setItem(STORE_KEY, config.authCookie);
+    taskLogger.incrementProgress(1);
+    taskLogger.succeed(previewSteps[1].succeed);
+    return config;
+}
+
+async function setupProject(previewUrl, projectName, toDir, authToken) {
+    const config = await setup(previewUrl, projectName, authToken);
+    const projectId = await findProjectId(config);
+    await downloadProject(projectId, config, toDir);
+    return () => pullChanges(projectId, config, toDir);
+};
+
+module.exports = {
+    setupProject : setupProject
+};

package/src/requirements.js

@@ -0,0 +1,250 @@
+const fs = require('fs');
+const os = require('os');
+const semver = require('semver');
+const prompt = require('prompt');
+
+const logger = require('./logger');
+const {
+    exec
+} = require('./exec');
+const loggerLabel = 'rn-cli-requirements';
+let VERSIONS = {
+    'NODE': '14.0.0',
+    'POD' : '1.9.0',
+    'JAVA': '11.0.0',
+    'REACT_NATIVE': '0.68.2',
+    'EXPO': '5.4.4',
+}
+
+// check if expo cli is installed globally or not
+// gradle check
+async function checkAvailability(cmd, transformFn, projectSrc) {
+    try {
+        let options = {};
+        if (projectSrc) {
+            options = {
+                cwd: projectSrc
+            }
+        }
+        let output = (await exec(cmd, ['--version'])).join('');
+
+        if (transformFn) {
+            output = transformFn(output);
+        }
+        // to just return version in x.x.x format
+        let version = output.match(/[0-9]+\.[0-9\.]+/)[0];
+
+        logger.info({
+            'label': loggerLabel,
+            'message': cmd + ' version available is ' + version
+        })
+        const requiredVersion = VERSIONS[cmd.toUpperCase()];
+        version = semver.coerce(version).version;
+        if (requiredVersion && semver.lt(version, requiredVersion)) {
+            logger.error('Minimum ' + cmd + ' version required is ' + requiredVersion + '. Please update the version.');
+            return false;
+        }
+        return version;
+    } catch(e) {
+        console.error(e);
+        logger.error('Observing error while checking ' + cmd.toUpperCase() + ' availability');
+        return false;
+    }
+}
+
+async function checkForGradleAvailability() {
+    return await checkAvailability('gradle', o => o && o.substring(o.indexOf('Gradle')) );
+}
+
+async function checkForAndroidStudioAvailability() {
+    // ANDROID_HOME environment variable is set or not. If it is set checking if its a valid path or no.
+    const ANDROID_HOME = process.env['ANDROID_HOME'];
+    const ANDROID_SDK_ROOT = process.env['ANDROID_SDK_ROOT']
+    if (ANDROID_HOME && !ANDROID_SDK_ROOT) {
+        logger.warn({
+            'label': loggerLabel,
+            'message': 'ANDROID_HOME is deprecated. Recommended to set ANDROID_SDK_ROOT'
+        });
+    }
+    envVariable = ANDROID_SDK_ROOT || ANDROID_HOME;
+    if (!envVariable) {
+        logger.error({
+            'label': loggerLabel,
+            'message': 'Failed to find \'ANDROID_SDK_ROOT\' environment variable. Try setting it manually.\n' +
+            'Try update your \'PATH\' to include path to valid SDK directory.'});
+        return false;
+    }
+    if (!fs.existsSync(envVariable)) {
+        logger.error({
+            'label': loggerLabel,
+            'message': '\'ANDROID_HOME\' environment variable is set to non-existent path: ' + process.env['ANDROID_HOME'] +
+            '\nTry update it manually to point to valid SDK directory.'});
+        return false;
+    }
+    let sdkPath = envVariable + '/tools/bin/sdkmanager';
+
+    // file extension has to be added for windows os for existsSync to work.
+    sdkPath = os.type().includes('Windows') ? sdkPath + '.bat' : sdkPath;
+
+    if (fs.existsSync(sdkPath)) {
+        logger.info({
+            'label': loggerLabel,
+            'message': 'Found Android SDK manager at ' + sdkPath
+        });
+        try {
+            await exec(sdkPath, ['--list']);
+        } catch(e) {
+            console.warn(e);
+        }
+    } else {
+        logger.warn({
+            'label': loggerLabel,
+            'message': 'Failed to find \'android-sdk\' in your \'PATH\'. Install Android-Studio before proceeding to build.'});
+    }
+    return true;
+}
+
+async function hasValidJavaVersion() {
+    const javaVersion = (await exec('java', ['-version'])).join('').match(/[0-9\.]+/)[0];
+
+    if (semver.lt(semver.coerce(javaVersion).version, VERSIONS.JAVA)) {
+        logger.error('Minimum java version required is' + VERSIONS.JAVA + '. Please update the java version.');
+        return false;
+    }
+
+    const envVariable = process.env['JAVA_HOME'];
+
+    if (!envVariable) {
+        logger.error({
+            'label': loggerLabel,
+            'message': 'Failed to find \'JAVA_HOME\' environment variable. Try setting it manually.\n' +
+            'Try update your \'PATH\' to include path to valid directory.'});
+        return false;
+    }
+    return true;
+}
+
+async function isGitInstalled() {
+    return await checkAvailability('git');
+}
+
+async function hasYarnPackage() {
+    return await checkAvailability('yarn');
+}
+
+async function isCocoaPodsInstalled() {
+    return await checkAvailability('pod');
+}
+
+async function hasValidNodeVersion() {
+    return await checkAvailability('node');
+}
+
+async function hasValidExpoVersion() {
+    // return await checkAvailability('expo');
+    return true;
+}
+
+function validateForAndroid(keyStore, storePassword, keyAlias, keyPassword) {
+    let errors = [];
+    if (!(keyStore && fs.existsSync(keyStore))) {
+        errors.push(`keystore is required (valid file): ${keyStore}`);
+    }
+    if (!keyAlias) {
+        errors.push('keyAlias is required.');
+    }
+    if (!keyPassword) {
+        errors.push('keyPassword is required.');
+    }
+    if (!storePassword) {
+        errors.push('storePassword is required.');
+    }
+    return errors;
+}
+
+function validateForIos(certificate, password, provisionalFilePath, buildType) {
+    let errors = [];
+    if (!(certificate && fs.existsSync(certificate))) {
+        errors.push(`p12 certificate does not exists : ${certificate}`);
+    }
+    if (!password) {
+        errors.push('password to unlock certificate is required.');
+    }
+    if (!(provisionalFilePath && fs.existsSync(provisionalFilePath))) {
+        errors.push(`Provisional file does not exists : ${provisionalFilePath}`);
+    }
+    if (!buildType) {
+        errors.push('Package type is required.');
+    }
+    return errors;
+}
+
+async function showConfirmation(message) {
+    return new Promise((resolve, reject) => {
+        prompt.get({
+            properties: {
+                confirm: {
+                    pattern: /^(yes|no|y|n)$/gi,
+                    description: message,
+                    message: 'Type yes/no',
+                    required: true,
+                    default: 'no'
+                }
+            }
+        }, function (err, result) {
+            if (err) {
+                reject();
+            }
+            resolve(result.confirm.toLowerCase());
+        });
+    });
+}
+
+async function canDoEmbed() {
+    let flag = true;
+    flag = flag && await hasValidNodeVersion();
+    flag = flag && await hasYarnPackage();
+    flag = flag && await isGitInstalled();
+    flag = flag && await hasValidExpoVersion();
+    return flag;
+}
+
+async function canDoIosBuild() {
+    let flag = true;
+    flag = flag && await hasValidNodeVersion();
+    flag = flag && await hasYarnPackage();
+    flag = flag && await isGitInstalled();
+    flag = flag && await hasValidExpoVersion();
+    flag = flag && await isCocoaPodsInstalled();
+    return flag;
+}
+
+async function canDoAndroidBuild() {
+    let flag = true;
+    flag = flag && !!await hasValidNodeVersion();
+    flag = flag && !!await hasYarnPackage();
+    flag = flag && !!await isGitInstalled();
+    flag = flag && !!await hasValidExpoVersion();
+    flag = flag && !!await hasValidJavaVersion();
+    flag = flag && !!await checkForGradleAvailability();
+    return flag;
+}
+
+module.exports = {
+    validateForIos: validateForIos,
+    validateForAndroid: validateForAndroid,
+    isCocoaPodsInstalled: isCocoaPodsInstalled,
+    isGitInstalled: isGitInstalled,
+    hasYarnPackage: hasYarnPackage,
+    hasValidNodeVersion: hasValidNodeVersion,
+    hasValidJavaVersion: hasValidJavaVersion,
+    showConfirmation: showConfirmation,
+    checkForAndroidStudioAvailability: checkForAndroidStudioAvailability,
+    checkForGradleAvailability: checkForGradleAvailability,
+    hasValidExpoVersion: hasValidExpoVersion,
+    VERSIONS: VERSIONS,
+    canDoEmbed: canDoEmbed,
+    canDoIosBuild: canDoIosBuild,
+    canDoAndroidBuild: canDoAndroidBuild
+}
+// TODO: support for multiple react native versions.