@24i/smartapps-bigscreen-rnv-build-engine 0.0.2-alpha.1321 → 0.0.2-alpha.1323

package/engine/src/scripts/release/deployToAppCenter.js

@@ -0,0 +1,79 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import { getConfigProp } from 'rnv/dist/core/common';
+import { getZippedPlatformBuildsFilePath } from '../../utils/zipBuildsByPlatforms';
+import { getUrlsMarkdown } from './urlsMarkdown';
+
+const appCenterRelease = (params) => {
+    const {
+        filePath, releaseNotesPath, buildVersion, token, projectName,
+        group = 'Collaborators', organizationName = '24i-Media',
+    } = params;
+    const app = `${organizationName}/${projectName}`;
+
+    execSync(
+        'appcenter distribute release '
+        + `--file "${filePath}" `
+        + `--release-notes-file "${releaseNotesPath}" `
+        + `--build-version "${buildVersion}" `
+        + `--app "${app}" `
+        + `--token "${token}" `
+        + `--group "${group}" `
+        + '--disable-telemetry',
+        { stdio: 'inherit' },
+    );
+};
+
+const getAppCenterConfigByPlatformName = (c, platformName) => {
+    try {
+        return c.buildConfig.platforms[platformName].deploy.appCenter || null;
+    } catch (error) {
+        return null;
+    }
+};
+
+const getTokenByPlatform = (platformName = '') => {
+    const envVariableName = `APPCENTER_TOKEN_${platformName.toUpperCase()}`;
+    return process.env[envVariableName] || '';
+};
+
+const processPlatform = (c, platformName) => {
+    const appCenterConfig = getAppCenterConfigByPlatformName(c, platformName);
+    if (!appCenterConfig) return;
+
+    const { appName } = appCenterConfig;
+
+    const token = getTokenByPlatform(platformName);
+    const zipPath = getZippedPlatformBuildsFilePath(c, platformName);
+    const buildVersion = getConfigProp(c, platformName, 'packageVersion', '');
+    const releaseNotesPath = getConfigProp(c, platformName, 'releaseNotes', {}).relativePath || '';
+
+    if (!appName || !token || !releaseNotesPath || !zipPath || !buildVersion) return;
+
+    const tempReleaseNotesPath = `RELEASE_NOTES_APPCENTER_${platformName.toUpperCase()}.md`;
+    if (fs.existsSync(tempReleaseNotesPath)) {
+        fs.unlinkSync(tempReleaseNotesPath);
+    }
+
+    execSync(`cat ${releaseNotesPath} >> ${tempReleaseNotesPath}`);
+    const urlsMarkdown = getUrlsMarkdown(c, [platformName]);
+    execSync(`echo "${urlsMarkdown}" >> ${tempReleaseNotesPath}`);
+
+    console.log(`Deploying ${platformName} platform to AppCenter.ms...`);
+    appCenterRelease({
+        projectName: appName,
+        buildVersion,
+        filePath: zipPath,
+        releaseNotesPath: tempReleaseNotesPath,
+        token,
+    });
+};
+
+const deployToAppCenter = (c) => {
+    const { supportedPlatforms = [] } = c.buildConfig.defaults || {};
+    supportedPlatforms.forEach((platformName) => processPlatform(c, platformName));
+};
+
+export {
+    deployToAppCenter,
+};

package/engine/src/scripts/release/githubRelease.js

@@ -0,0 +1,138 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import { strict } from 'assert';
+import { basename } from 'path';
+import { getZippedPlatformBuildsFilePath } from '../../utils/zipBuildsByPlatforms';
+import { getUrlsMarkdown } from './urlsMarkdown';
+
+const { ok } = strict;
+
+const token = process.env.GITHUB_TOKEN;
+const targetCommit = process.env.TRAVIS_COMMIT;
+
+const githubContentType = 'application/vnd.github.v3+json';
+const githubReleaseNotesPath = 'RELEASE_NOTES_GITHUB.md';
+
+const handleResponseErrors = (response) => {
+    const { errors, message } = response;
+
+    if (message && !errors) throw new Error(`GitHub error: ${message}`);
+    if (!errors) return;
+
+    const makeErrorDetailString = (error = {}) => {
+        return Object.keys(error)
+            .map((key) => `${key}: "${error[key]}"`)
+            .join(', ');
+    };
+
+    const errorsDetails = errors.map(makeErrorDetailString);
+    throw new Error(`GitHub error: ${message || ''}\n${errorsDetails.join('\n')}`);
+};
+
+const getReleaseNotesPath = (c) => {
+    try {
+        return c.buildConfig.common.releaseNotes.relativePath || '';
+    } catch (error) {
+        return '';
+    }
+};
+
+const deleteFileIfExists = (filePath) => {
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+    }
+};
+
+const makeGitHubReleaseNotes = (c) => {
+    const releaseNotesPath = getReleaseNotesPath(c);
+    ok(releaseNotesPath, 'The path to the file with release notes is missing!');
+
+    deleteFileIfExists(githubReleaseNotesPath);
+    execSync(`sed '1d;2d' ${releaseNotesPath} >> ${githubReleaseNotesPath}`); // copy without first two lines
+    const textToAppend = getUrlsMarkdown(c);
+    execSync(`echo "${textToAppend}" >> ${githubReleaseNotesPath}`);
+};
+
+const createRelease = (c) => {
+    const { packageVersion, git = {} } = c.buildConfig.common;
+    const versionLabel = `v${packageVersion}`;
+
+    ok(token, 'process.env.GITHUB_TOKEN is not set!');
+    ok(targetCommit, 'process.env.TRAVIS_COMMIT is not set!');
+    ok(git.owner, 'Missing value for rnv config prop: common.git.owner');
+    ok(git.repo, 'Missing value for rnv config prop: common.git.repo');
+    ok(packageVersion);
+
+    makeGitHubReleaseNotes(c);
+    const releaseNotesContent = fs.readFileSync(githubReleaseNotesPath).toString();
+
+    const data = {
+        tag_name: versionLabel,
+        target_commitish: targetCommit,
+        name: versionLabel,
+        body: releaseNotesContent,
+        draft: false,
+        prerelease: false,
+    };
+
+    const url = `https://api.github.com/repos/${git.owner}/${git.repo}/releases`;
+    const headers = `-H "Accept: ${githubContentType}" -H "Authorization: token ${token}"`;
+    const dataStringWithFixedSingleQuotes = JSON.stringify(data).replace(/'/g, "'\\''");
+    const cmd = `curl -X POST ${headers} ${url} -d '${dataStringWithFixedSingleQuotes}'`;
+
+    console.log(`Pushing GitHub Release: ${versionLabel}...`);
+    const responseString = execSync(cmd, { stdio: 'pipe' }).toString();
+    const response = JSON.parse(responseString);
+    handleResponseErrors(response);
+    console.log('Pushing done.');
+
+    return response;
+};
+
+const getFileMimeType = (filepath) => {
+    const cmd = `file --mime-type -b ${filepath}`;
+    return execSync(cmd, { stdio: 'pipe' })
+        .toString()
+        .replace(/\r?\n/, '');
+};
+
+const uploadAsset = (uploadUrl = '', filePath) => {
+    if (!uploadUrl) return null;
+    const url = `${uploadUrl.replace('{?name,label}', '')}`;
+    const headers = `-H "Accept: ${githubContentType}" -H "Authorization: token ${token}" -H "content-type: ${getFileMimeType(filePath)}" -H "content-length: ${fs.statSync(filePath).size}"`;
+    const cmd = `curl --data-binary @"${filePath}" ${headers} ${url}?name=${basename(filePath)}`;
+
+    console.log(`Uploading ${filePath} asset to created GitHub Release...`);
+    const responseString = execSync(cmd, { stdio: 'pipe' }).toString();
+    const uploadResponse = JSON.parse(responseString);
+    handleResponseErrors(uploadResponse);
+    console.log('Uploading done.');
+
+    return uploadResponse;
+};
+
+const uploadZipWithPlatformBuilds = (c, platformName, githubUploadUrl) => {
+    const zipFilePath = getZippedPlatformBuildsFilePath(c, platformName);
+
+    if (zipFilePath) {
+        uploadAsset(githubUploadUrl, zipFilePath);
+    }
+};
+
+const githubRelease = (c) => {
+    const releaseResponse = createRelease(c) || {};
+    const uploadUrl = releaseResponse.upload_url;
+    ok(uploadUrl, 'Missing "upload_url" in release response!');
+
+    const { defaults = {} } = c.buildConfig;
+    const { supportedPlatforms = [] } = defaults;
+
+    supportedPlatforms.forEach((platformName) => {
+        uploadZipWithPlatformBuilds(c, platformName, uploadUrl);
+    });
+    deleteFileIfExists(githubReleaseNotesPath);
+};
+
+export {
+    githubRelease,
+};

package/engine/src/scripts/release/notifySlack/makePayload.js

@@ -0,0 +1,103 @@
+import { Section, Actions, Divider, Context } from './slackBlockKitBuilder';
+import { getDeployLocations } from '../../../utils/getDeployLocations';
+
+const getVersionsObject = (c) => {
+    const { versions = [] } = getDeployLocations(c) || {};
+    return versions;
+};
+
+const getVersion = (c) => {
+    return Object.keys(getVersionsObject(c))[0] || '';
+}
+
+const getPlatformsObject = (c) => {
+    const version = getVersion(c);
+    const { platforms = {} } = getVersionsObject(c)[version] || {};
+    return platforms;
+};
+
+const getCommonAppName = (c) => {
+    try { return c.buildConfig.common.appName }
+    catch (error) { return '' }
+};
+
+const makeFlavoursMarkdown = (platformName, entries) => {
+    return entries
+        .map(([flavour, flavourData]) => {
+            const { indexUrl, packageUrl } = flavourData;
+            return `- *${flavour}* [<${packageUrl}|Download>] [<${indexUrl}|Open deployed index.html>]`;
+        })
+        .join('\n');
+};
+
+const makePackagePayload = (c, platformName) => {
+    const platformData = getPlatformsObject(c)[platformName];
+    const flavoursEntries = Object.entries(platformData);
+
+    return [
+        Divider.plain(),
+        Context.mrkdwns([`Platform: *${platformName}*`]),
+        Context.mrkdwns([makeFlavoursMarkdown(platformName, flavoursEntries)]),
+    ];
+};
+
+const makePackagesPayload = (c) => {
+    const platformList = Object.keys(getPlatformsObject(c));
+    return platformList
+        .map((platformName) => makePackagePayload(c, platformName))
+        .flat();
+};
+
+const makeHeaderPayload = (c, { title = '', buttons }) => {
+    const { travisBuild, gitHubRelease } = buttons || {};
+    const { owner, repo } = c.buildConfig.common.git || {};
+    const version = getVersion(c);
+
+    return [
+        Divider.plain(),
+        Section.mrkdwn(title),
+        Context.mrkdwns([`Version: *${version}*`]),
+        Actions.buttons([
+            travisBuild ? {
+                text: 'View Travis Build Log',
+                url: process.env.TRAVIS_BUILD_WEB_URL || `https://travis-ci.com/github/${owner}/${repo}/branches`,
+            } : null,
+            gitHubRelease ? {
+                text: 'View GitHub Release',
+                url: `https://github.com/${owner}/${repo}/releases/tag/${version}`,
+            } : null,
+        ].filter(Boolean)),
+    ];
+};
+
+const makePayload = (c, title, buttons) => ({
+    blocks: [
+        ...makeHeaderPayload(c, { title, buttons }),
+        ...makePackagesPayload(c),
+    ],
+});
+
+const makeDevelopmentPayload = (c) => {
+    const title = `There are new *development* builds for *${getCommonAppName(c)}* app!`;
+    const buttons = { travisBuild: true };
+    return makePayload(c, title, buttons);
+};
+
+const makeReleaseCandidatePayload = (c) => {
+    const title = `There are new *release candidate* builds for *${getCommonAppName(c)}* app!`;
+    const buttons = { travisBuild: true };
+    return makePayload(c, title, buttons);
+
+};
+
+const makeDistributionPayload = (c) => {
+    const title = `There are new *distribution* builds for *${getCommonAppName(c)}* app!`;
+    const buttons = { travisBuild: true, gitHubRelease: true };
+    return makePayload(c, title, buttons);
+};
+
+export {
+    makeDevelopmentPayload,
+    makeReleaseCandidatePayload,
+    makeDistributionPayload,
+};

package/engine/src/scripts/release/notifySlack/notifySlack.js

@@ -0,0 +1,26 @@
+import { execSync } from 'child_process';
+import * as payload from './makePayload';
+
+const getPayload = (c) => {
+    const releaseType = c.runtime.scheme;
+
+    switch (releaseType) {
+        case 'dev:latest': return payload.makeDevelopmentPayload(c);
+        case 'rc:latest': return payload.makeReleaseCandidatePayload(c);
+        case 'release:dist': return payload.makeDistributionPayload(c);
+        default: throw new Error('Notify Slack: unsupported or undefined release type! Did you pass it as an argument?');
+    }
+};
+
+const notifySlack = (c) => {
+    const contentType = '"Content-type: application/json"';
+    const data = `--data '${JSON.stringify(getPayload(c))}'`;
+    const webHookUrl = c.buildConfig?.common?.deploy?.slack?.webhookUrl || '';
+
+    const cmd = `curl -X POST -H ${contentType} ${data} ${webHookUrl}`;
+    execSync(cmd, { stdio: 'inherit' });
+};
+
+export {
+    notifySlack,
+};

package/engine/src/scripts/release/notifySlack/slackBlockKitBuilder.js

@@ -0,0 +1,44 @@
+// https://app.slack.com/block-kit-builder
+
+const mrkdwn = (text) => ({ type: 'mrkdwn', text });
+
+const plainText = (text) => ({
+    type: 'plain_text',
+    text,
+    emoji: true,
+});
+
+const buttonWithUrl = ({ text, url }) => ({
+    type: 'button',
+    text: plainText(text),
+    url,
+});
+
+const Section = {
+    mrkdwn: (text) => ({
+        type: 'section',
+        text: mrkdwn(text),
+    }),
+};
+const Actions = {
+    buttons: (btnsData) => ({
+        type: 'actions',
+        elements: btnsData.map(buttonWithUrl),
+    }),
+};
+const Divider = {
+    plain: () => ({ type: 'divider' }),
+};
+const Context = {
+    mrkdwns: (texts) => ({
+        type: 'context',
+        elements: texts.map(mrkdwn),
+    }),
+};
+
+export {
+    Section,
+    Actions,
+    Divider,
+    Context,
+};

package/engine/src/scripts/release/sentryRelease.js

@@ -0,0 +1,79 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+
+const UNSUPPORTED_PLATFORMS = ['webtv'];
+
+const executeSync = (cmd) => execSync(cmd, { stdio: 'inherit' });
+
+const createNewRelease = (version) => {
+    executeSync(`sentry-cli releases new ${version}`);
+};
+
+const uploadSourceMaps = (params) => {
+    const { version, sourceMapsPath, urlPrefix } = params;
+    executeSync(
+        'sentry-cli releases '
+        + `files ${version} `
+        + `upload-sourcemaps ${sourceMapsPath} `
+        + `--url-prefix "~/${urlPrefix}" `
+        + '--rewrite --validate',
+    );
+};
+
+const setReleaseCommits = (version) => {
+    try {
+        executeSync(`sentry-cli releases set-commits ${version} --auto --log-level=debug`);
+    } catch (error) {
+        console.log('Sentry release commits failed: ', error);
+    }
+};
+
+const finalizeRelease = (version) => {
+    executeSync(`sentry-cli releases finalize ${version}`);
+};
+
+const processPlatform = (c, platform, version) => {
+    const processFlavour = (flavour) => {
+        const { platformBuildsDir } = c.buildConfig.paths;
+        const sourceMapsPath = `${platformBuildsDir}/${flavour}_${platform}-public/public/content/js`;
+        const urlPrefix = `builds/${platform}/${flavour}/dist/${version}/public/content/js/`;
+        if (!fs.existsSync(sourceMapsPath)) return;
+
+        console.log(`Uploading ${flavour}_${platform} sourcemaps to Sentry...`);
+        uploadSourceMaps({ version, sourceMapsPath, urlPrefix });
+    };
+    const { supportedFlavours = [] } = c.buildConfig.platforms[platform]?.deploy || {};
+    supportedFlavours.forEach(processFlavour);
+};
+
+const isSentryProjectConfigured = () => {
+    const cmd = execSync('sentry-cli info --config-status-json');
+    const sentryConfig = JSON.parse(cmd.toString()) || {};
+    return !!sentryConfig.config?.project;
+}
+
+const sentryRelease = (c) => {
+    if (!isSentryProjectConfigured()) {
+        console.log('Project is not defined...');
+        return;
+    }
+
+    const version = `v${c.buildConfig.common?.packageVersion}`;
+    if (!version) return;
+
+    const { supportedPlatforms = [] } = c.buildConfig.defaults || {};
+    const supportedPlatformsBySentry = supportedPlatforms.filter(
+        (platform) => !UNSUPPORTED_PLATFORMS.includes(platform),
+    );
+
+    createNewRelease(version);
+    supportedPlatformsBySentry.forEach((platform) => processPlatform(c, platform, version));
+    setReleaseCommits(version);
+    finalizeRelease(version);
+
+    console.log('Source Maps uploaded...');
+};
+
+export {
+    sentryRelease,
+};

package/engine/src/scripts/release/urlsMarkdown.js

@@ -0,0 +1,85 @@
+import { getDeployLocations } from '../../utils/getDeployLocations';
+import { strict } from 'assert';
+
+const { ok } = strict;
+
+const newLine = '\r\n';
+
+const getDataToProceed = (c, customPlatformList = []) => {
+    const locations = getDeployLocations(c);
+    ok(locations, 'It seems that file with remote locations has not been generated! Try to check rnv build hooks...');
+
+    const { versions } = locations;
+    const { platforms } = versions[Object.keys(versions)[0]];
+
+    if (!customPlatformList.length) return platforms;
+
+    const outputData = {};
+    const addToOutputIfPlatformHasData = (platformName) => {
+        const platformData = platforms[platformName];
+        if (platformData) {
+            outputData[platformName] = platformData;
+        }
+    };
+    customPlatformList.forEach(addToOutputIfPlatformHasData);
+    return outputData;
+};
+
+const beautifyPlatformName = (platformName) => {
+    switch (platformName.toLowerCase()) {
+        case 'entone': return 'Entone';
+        case 'hbbtv': return 'HbbTV';
+        case 'tizen': return 'Tizen (Samsung)';
+        case 'webos': return 'webOS (LG)';
+        case 'webtv': return 'WebTV';
+        default: return platformName;
+    }
+};
+
+const getPlatformOutput = (data, platformName) => {
+    if (platformName === 'tizen' || platformName === 'webos') {
+        return '';
+    }
+
+    const platformData = data[platformName];
+    let output = `**${beautifyPlatformName(platformName)}**${newLine}`;
+
+    const processPlatformEntry = ([flavour, flavourData]) => {
+        const { indexUrl } = flavourData;
+        output += `* [${flavour}](${indexUrl})${newLine}`;
+    };
+
+    Object.entries(platformData).forEach(processPlatformEntry);
+    return output;
+};
+
+/*
+ === OUTPUT EXAMPLE start ===
+ ## URL
+ **Entone**
+ * [flavour1](http://.../index.html)
+ * [flavour2](http://.../index.html)
+
+ **WebTV**
+ * [flavour1](http://.../index.html)
+ * [flavour2](http://.../index.html)
+ === OUTPUT EXAMPLE end ===
+ */
+const getUrlsMarkdown = (c, customPlatformList) => {
+    const dataToProceed = getDataToProceed(c, customPlatformList);
+
+    const markdownWithoutHeader = Object.keys(dataToProceed)
+        .map((platformName) => getPlatformOutput(dataToProceed, platformName))
+        .filter(Boolean)
+        .join(newLine);
+
+    if (markdownWithoutHeader.length) {
+        const urlHeader = `${newLine}## URL${newLine}`;
+        return urlHeader + markdownWithoutHeader;
+    }
+    return '';
+};
+
+export {
+    getUrlsMarkdown,
+};

package/engine/src/scripts/releaseAllWithScheme.js

@@ -0,0 +1,91 @@
+import { execSync } from 'child_process';
+import { forEachSupportedPlatformFlavour } from '../utils/forEachSupportedPlatformFlavour';
+import { getBaseConfig } from '../utils/getBaseConfig';
+import { getDeployLocations } from '../utils/getDeployLocations';
+import { zipBuildsByPlatforms } from '../utils/zipBuildsByPlatforms';
+import { deleteSourceMaps } from './release/deleteSourceMaps';
+import { deployToAppCenter } from './release/deployToAppCenter';
+import { githubRelease } from './release/githubRelease';
+import { notifySlack } from './release/notifySlack/notifySlack';
+import { sentryRelease } from './release/sentryRelease';
+
+const deployTask = (options) => {
+    const { scheme, platform, flavour } = options;
+    const cmd = `npx rnv deploy -s ${scheme} -p ${platform} -c ${flavour} --ci --only`;
+    execSync(cmd, { stdio: 'inherit' });
+};
+
+const deployBuilds = (c) => {
+    console.log(`Deploying the builds...`);
+    forEachSupportedPlatformFlavour(c, deployTask);
+    return true;
+};
+
+const doLatestDevelopmentRelease = (c) => {
+    console.log('doLatestDevelopmentRelease');
+    return deployBuilds(c);
+};
+
+const doLatestReleaseCandidateRelease = (c) => {
+    console.log('doLatestReleaseCandidateRelease');
+    deployBuilds(c);
+    notifySlack(c);
+
+    return true;
+};
+
+const doLatestRelease = (c) => {
+    console.log('doLatestRelease');
+    return deployBuilds(c);
+};
+
+const doDistributionRelease = (c) => {
+    console.log('doDistributionRelease');
+
+    zipBuildsByPlatforms(c);
+    deployBuilds(c);
+    sentryRelease(c);
+    deleteSourceMaps(c);
+    githubRelease(c);
+    deployToAppCenter(c);
+    notifySlack(c);
+
+    return true;
+};
+
+const releaseAllWithScheme = () => {
+    const scheme = process.argv[2];
+    if (!scheme) {
+        throw new Error ('No scheme name to use found! Please use rnv scheme name as a param.');
+    }
+
+    const c = getBaseConfig();
+    c.runtime.scheme = scheme;
+
+    switch (scheme) {
+        case 'dev:latest':
+            doLatestDevelopmentRelease(c);
+            break;
+        case 'rc:latest':
+            doLatestReleaseCandidateRelease(c);
+            break;
+        case 'release:latest':
+            doLatestRelease(c);
+            break;
+        case 'release:dist':
+            doDistributionRelease(c);
+            break;
+        default:
+            throw new Error('Unsupported scheme to release!');
+    }
+
+    console.log(JSON.stringify(getDeployLocations(c), null, 4));
+    return true;
+};
+
+const startTimestamp = Date.now();
+
+releaseAllWithScheme()
+
+const scriptTotalTimeInSeconds = Math.ceil((Date.now() - startTimestamp) / 1000);
+console.log(`buildAllWithScheme: done in ${scriptTotalTimeInSeconds} second(s)!`);

package/engine/src/scripts/utils/cmdUtils.js

@@ -0,0 +1,16 @@
+const { execSync } = require('child_process');
+
+const cmdSync = (command, options) => execSync(command, options);
+
+const cmdSyncInheritOut = (command) => cmdSync(command, { stdio: 'inherit' });
+
+const cmdSyncPipeOut = (command) => cmdSync(command, { stdio: 'pipe' });
+
+const cmdSyncTrimOut = (command) => cmdSync(command).toString().trim();
+
+module.exports = {
+    cmdSync,
+    cmdSyncInheritOut,
+    cmdSyncPipeOut,
+    cmdSyncTrimOut,
+};

package/engine/src/scripts/utils/fsUtils.js

@@ -0,0 +1,14 @@
+const fs = require('fs');
+const { ok } = require('assert').strict;
+
+const getFileContentAsString = (filePath) => fs.readFileSync(filePath).toString();
+
+const assertPath = (path) => {
+    const errorMsg = `File or path ${path} does not exist!`;
+    ok(fs.existsSync(path), errorMsg);
+};
+
+module.exports = {
+    getFileContentAsString,
+    assertPath,
+};