@eui/tools 6.2.10 → 6.2.12

package/scripts/csdr/release/package/release-virtual-remote.js

@@ -0,0 +1,154 @@
+'use strict';
+
+// GLOBAL
+const path = require('path');
+
+// UTILS
+const utils = require('../../../utils');
+
+// CSDR RELATED
+const configUtils = require('../../config/config-utils');
+
+// INNER MODULES
+const innerCommon = require('./common');
+const innerRemote = require('./remote');
+
+
+
+
+module.exports.run = () => {
+    utils.tools.logBanner('Starting virtual remote pipeline');
+
+    // fetching package from config based on default arg
+    const pkg = configUtils.remotes.getRemote();
+
+    // checking if the package can be retrieved from args
+    if (!pkg.name) {
+      utils.tools.logError('ERROR : "package" NOT PROVIDED as argument !!!');
+      process.exit(1);
+    }
+
+    // Get branches flags
+    const branches = innerCommon.getBranches();
+
+    // Get envTarget (used by remotes)
+    const envTarget = innerCommon.getEnvTarget();
+
+    // Get compositeType (used by remotes)
+    const compositeType = innerCommon.getCompositeType();
+
+
+    // local saved vars
+    var newVersion, pkgMetadata, pkgCompositeDeps;
+
+
+    return Promise.resolve()
+
+      // RELEASE PACKAGE START
+      .then(() => {
+        return innerCommon.init(pkg, envTarget, compositeType);
+      })
+
+      // FOR UI and REMOTES clone metadata repositories
+      .then(() => {
+        return innerCommon.cloneMetadataRepos();
+      })
+
+
+      // EXECUTING PRE BUILD SCRIPT IF AVAILABLE
+      .then(() => {
+        return innerCommon.preBuild(pkg);
+      })
+
+
+      // INSTALL dependencies by type
+      .then(() => {
+        return innerRemote.install(pkg, envTarget, compositeType);
+      })
+      .then((compositeDeps) => {
+        // storing for later use
+        pkgCompositeDeps = compositeDeps;
+      })
+
+
+      // BUILD PACKAGE
+      .then(() => {
+        return utils.buildPackage.build(pkg, true);
+      })
+
+
+      // GENERATE and UPDATE new version
+      .then(() => {
+        return innerCommon.updateVersion(pkg, pkgMetadata, envTarget);
+      })
+      .then((version) => {
+        // storing version for later use
+        newVersion = version;
+      })
+
+
+      // EXECUTING GLOBAL POST BUILD
+      .then(() => {
+        return innerCommon.postBuild(pkg, newVersion);
+      })
+
+
+      // STORING METADATA ASSETS
+      .then(() => {
+        return innerCommon.storeMetadataAssets(pkg, pkgCompositeDeps);
+      })
+
+
+      // PUBLISH PACKAGE
+      .then(() => {
+        return utils.publish.publish(pkg);
+      })
+
+
+      // EXECUTING POST PUBLISH SCRIPT IF AVAILABLE
+      .then(() => {
+        return utils.publish.postPublish(pkg);
+      })
+
+
+      // STORING CENTRALIZED METADATA
+      .then(() => {
+        // get run duration
+        const duration = utils.pipeline.getTimerDuration();
+        return innerCommon.storeMetadata(pkg, newVersion, pkgMetadata, pkgCompositeDeps, duration, envTarget);
+      })
+
+      // STORING PACKAGE HISTORY
+      .then(() => {
+        if (branches.isMaster && pkg.remote) {
+          return innerCommon.generateDiffReport(pkg, newVersion);
+        }
+      })
+
+      // COMMITING METADATA
+      .then(() => {
+        return innerCommon.commitMetadata(pkg, newVersion);
+      })
+
+
+      // EXPORT ADDITIONAL PIPELINE VARIABLES
+      .then(() => {
+        return innerCommon.exportPipelineVariables(pkg, compositeType);
+      })
+
+      // SEND SUCCESS NOTIFICATION
+      .then(() => {
+        return innerCommon.sendSuccessNotification(pkg, newVersion, pkgMetadata)
+          .then(() => {
+            innerCommon.close(pkg);
+          });
+      })
+
+      .catch((e) => {
+        return innerCommon.sendErrorNotification(pkg, e, pkgMetadata)
+          .then(() => {
+            innerCommon.close(pkg);
+            process.exit(1);
+          });
+      })
+}

package/scripts/csdr/version/package-common.js

@@ -54,7 +54,7 @@ const writePackageJson = (pkg, newVersion, isSnapshot, isNextBranch, isSupportBr
       if (!pkg.parent) {
         return Promise.resolve()
           .then(() => {
-            return writePackageJsonCore(newVersion, pkg.paths.pkgDirectory, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch, envTarget);
+            return writePackageJsonCore(newVersion, pkg.paths.root, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch, envTarget);
           })
           .then(() => {
             if (!pkg.element && !pkg.config) {
@@ -68,7 +68,7 @@ const writePackageJson = (pkg, newVersion, isSnapshot, isNextBranch, isSupportBr
       } else {
         return Promise.resolve()
           .then(() => {
-            return writePackageJsonCore(newVersion, pkg.paths.pkgDirectory, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch, envTarget);
+            return writePackageJsonCore(newVersion, pkg.paths.root, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch, envTarget);
           })
           .then(() => {
             let linkedPackages = Object.keys(pkg.packages)
@@ -119,18 +119,18 @@ const writePomXml = (pkg, newVersion, isSnapshot, isForceTimestamp = true) => {
 
     .then((mavenSettingsFile) => {
 
-      tools.logInfo(`Executing mvn versions on : ${pkg.paths.pkgDirectory}`);
+      tools.logInfo(`Executing mvn versions on : ${pkg.paths.root}`);
 
-      execa.shellSync('mvn versions:set -T1 -DnewVersion=' + newVersion + ' -s ' + mavenSettingsFile, { cwd: pkg.paths.pkgDirectory });
-      execa.shellSync('mvn versions:commit -T1' + ' -s ' + mavenSettingsFile, { cwd: pkg.paths.pkgDirectory });
+      execa.shellSync('mvn versions:set -T1 -DnewVersion=' + newVersion + ' -s ' + mavenSettingsFile, { cwd: pkg.paths.root });
+      execa.shellSync('mvn versions:commit -T1' + ' -s ' + mavenSettingsFile, { cwd: pkg.paths.root });
 
       if (isForceTimestamp) {
         // timestamp file is forced to have at least one file to commit, as snapshot release
         // for backend can keep the same version until its latest
-        const tsversionFile = path.resolve(pkg.paths.pkgDirectory, '.tsversion');
+        const tsversionFile = path.resolve(pkg.paths.root, '.tsversion');
         tools.writeFileContent(tsversionFile, Date.now().toString());
 
-        const versionFile = path.resolve(pkg.paths.pkgDirectory, '.version.properties');
+        const versionFile = path.resolve(pkg.paths.root, '.version.properties');
         tools.writeFileContent(versionFile, newVersion);
       }
     })
@@ -170,14 +170,14 @@ module.exports.getCurrentVersion = (pkg) => {
         if (pkg.build && pkg.build.nodejs) {
           tools.logInfo('UI package => extracting from package.json');
 
-          const pathPkgJson = path.resolve(pkg.paths.pkgDirectory, 'package.json');
+          const pathPkgJson = path.resolve(pkg.paths.root, 'package.json');
           const pkgJson = require(pathPkgJson);
           currentVersion = pkgJson.version;
 
           // by default maven java backend is taken into account
         } else {
           tools.logInfo('Backend => extracting pom.xml');
-          const xmlContent = tools.getXMLJsContent(path.join(pkg.paths.pkgDirectory, 'pom.xml'));
+          const xmlContent = tools.getXMLJsContent(path.join(pkg.paths.root, 'pom.xml'));
 
           tools.logInfo('Content found:');
           console.log(xmlContent);
@@ -188,7 +188,7 @@ module.exports.getCurrentVersion = (pkg) => {
       } else {
         tools.logInfo('UI package => extracting from package.json');
 
-        const pathPkgJson = path.resolve(pkg.paths.pkgDirectory, 'package.json');
+        const pathPkgJson = path.resolve(pkg.paths.root, 'package.json');
         const pkgJson = require(pathPkgJson);
         currentVersion = pkgJson.version;
       }

package/scripts/utils/build/package/build-package-utils.js

@@ -134,7 +134,7 @@ module.exports.preBuild = (pkg) => {
 
   return Promise.resolve()
     .then(() => {
-      const prebuildScript = path.join(pkg.paths.pkgDirectory, 'pre-build.js');
+      const prebuildScript = path.join(pkg.paths.root, 'pre-build.js');
       if (!dryRun && tools.isFileExists(prebuildScript)) {
         return tools.runScript(`node ${prebuildScript}`);
       } else {
@@ -159,7 +159,7 @@ module.exports.postBuild = (pkg) => {
   return Promise.resolve()
     .then(() => {
       tools.logInfo('Executing post-build.js script if present in package');
-      const postbuildScript = path.join(pkg.paths.pkgDirectory, 'post-build.js');
+      const postbuildScript = path.join(pkg.paths.root, 'post-build.js');
       if (!dryRun && tools.isFileExists(postbuildScript)) {
         return tools.runScript(`node ${postbuildScript}`);
       } else {
@@ -170,7 +170,7 @@ module.exports.postBuild = (pkg) => {
     // Clean up temporary sonar generated folder and files
     .then(() => {
       tools.logInfo('Cleaning sonar temporary assets if exist');
-      const sonarTempPath = path.join(pkg.paths.pkgDirectory, '.scannerwork');
+      const sonarTempPath = path.join(pkg.paths.root, '.scannerwork');
       if (tools.isDirExists(sonarTempPath)) {
         return tools.rimraf(sonarTempPath);
       }
@@ -190,7 +190,7 @@ module.exports.buildSubEntry = (pkg, subEntry) => {
     .then(() => {
       tools.logInfo(`Building sub-entry : ${subEntry} of package : ${pkg.name}`);
       // console.log(pkg);
-      return tools.getFilesGlob(pkg.paths.pkgRootDirectory, `**/package.json`);
+      return tools.getFilesGlob(pkg.paths.root, `**/package.json`);
     })
 
     .then((files) => {
@@ -227,8 +227,8 @@ module.exports.buildSubEntry = (pkg, subEntry) => {
           tools.logInfo('Testing...');
           const ng = path.resolve(process.cwd(), 'node_modules', '@angular', 'cli', 'bin', 'ng');
           let args = ['--max_old_space_size=8096', ng, 'test', subEntry, '--code-coverage', '--watch=false'];
-          tools.logInfo(`running ng test : with args: ${args} on folder : ${pkg.paths.pkgRootDirectory}`);
-          return execa('node', args, { cwd: pkg.paths.pkgRootDirectory, stdio: 'inherit' });
+          tools.logInfo(`running ng test : with args: ${args} on folder : ${pkg.paths.root}`);
+          return execa('node', args, { cwd: pkg.paths.root, stdio: 'inherit' });
         }
       }
     })
@@ -237,7 +237,7 @@ module.exports.buildSubEntry = (pkg, subEntry) => {
 
       let args = ['--max_old_space_size=8096', ng, 'build', subEntry];
 
-      return execa('node', args, { cwd: pkg.paths.pkgRootDirectory, stdio: 'inherit' });
+      return execa('node', args, { cwd: pkg.paths.root, stdio: 'inherit' });
     })
 
     .then(() => {

package/scripts/utils/publish/npm.js

@@ -15,7 +15,7 @@ const { dryRun, registry } = tools.getArgs();
 
 
 const getPkgVersion = (pkg) => {
-  const pathPkgJson = path.resolve(pkg.paths.pkgPublish, 'package.json');
+  const pathPkgJson = path.resolve(pkg.paths.publish, 'package.json');
   delete require.cache[pathPkgJson];
   require(pathPkgJson);
   const { version } = require(pathPkgJson);
@@ -23,9 +23,9 @@ const getPkgVersion = (pkg) => {
 }
 
 const publishCore = (pkg, registry, isPublicAccess) => {
-  tools.logInfo(`Publishing package "${pkg.name}" from "${pkg.paths.pkgPublish}" on ${registry}`);
+  tools.logInfo(`Publishing package "${pkg.name}" from "${pkg.paths.publish}" on ${registry}`);
 
-  let command = `npm publish ${pkg.paths.pkgPublish} --registry ${registry}`;
+  let command = `npm publish ${pkg.paths.publish} --registry ${registry}`;
 
   if (isPublicAccess) {
     command += ' --access public';
@@ -59,7 +59,7 @@ const publishCore = (pkg, registry, isPublicAccess) => {
       .then(() => {
         tools.logInfo('Write version properties file');
 
-        const versionFile = path.resolve(pkg.paths.pkgDirectory, '.version.properties');
+        const versionFile = path.resolve(pkg.paths.root, '.version.properties');
         tools.writeFileContent(versionFile, version);
       })
 
@@ -164,9 +164,14 @@ module.exports.publish = (pkg) => {
     .then(() => {
 
       if (!pkg.parent) {
-        // building normal package without linked children
-        const pkgFull = configUtils.packages.getPackage(pkg.name);  // TO CHECK
-        return publishPackage(pkgFull);
+        if (pkg.remote && pkg.virtual) {
+          return publishPackage(pkg);
+
+        } else {
+          // building normal package without linked children
+          const pkgFull = configUtils.packages.getPackage(pkg.name);  // TO CHECK
+          return publishPackage(pkgFull);
+        }
 
       } else {
 

package/scripts/utils/publish/publish-utils.js

@@ -25,7 +25,7 @@ module.exports.publish = (pkg) => {
 }
 
 module.exports.postPublish = (pkg) => {
-  const postpublishScript = path.join(pkg.paths.pkgDirectory, 'post-publish.js');
+  const postpublishScript = path.join(pkg.paths.root, 'post-publish.js');
   if (!dryRun && tools.isFileExists(postpublishScript)) {
     return tools.runScript(`node ${postpublishScript}`);
   } else {

package/scripts/utils/tools.js

@@ -81,6 +81,29 @@ function getArgs() {
 }
 
 
+function convertBooleanArg(arg) {
+  if (arg && typeof(arg) === 'boolean') {
+    return false;
+  } else {
+    if (arg) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+}
+
+function convertStringArg(arg, defaultValue = null) {
+  if (arg && typeof(arg) === 'boolean') {
+    return defaultValue
+  } else {
+    if (arg) {
+      return arg;
+    } else {
+      return defaultValue;
+    }
+  }
+}
 
 
 /* -------------------------------------------------------------------------------------------
@@ -796,6 +819,8 @@ module.exports.sortArray = sortArray;
 module.exports.removeArrayDuplicates = removeArrayDuplicates;
 module.exports.getArraySum = getArraySum;
 module.exports.getArgs = getArgs;
+module.exports.convertBooleanArg = convertBooleanArg;
+module.exports.convertStringArg = convertStringArg;
 module.exports.getXMLJsContent = getXMLJsContent;
 module.exports.getFolders = getFolders;
 module.exports.getFiles = getFiles;