@eui/tools 4.21.10 → 5.0.0-rc.12

package/scripts/csdr/version/common.js

@@ -0,0 +1,277 @@
+'use strict';
+
+// externals
+const semver = require('semver');
+
+// local
+const tools = require('../../utils/tools');
+
+
+const getNewVersionForDev = (versionsMetadata, envsMetadata, rootEnv) => {
+  let version;
+  const lastIntMetadata = envsMetadata[rootEnv];
+
+  if (lastIntMetadata) {
+    const rootVersion = semver.coerce(envsMetadata[rootEnv].version).raw;
+    version = semver.inc(rootVersion, 'major') + '-SNAPSHOT';
+  } else {
+    version = '1.0.0-SNAPSHOT';
+  }
+
+  tools.logInfo(`Probable new version : ${version}`);
+
+  // if no versions history is found for the current project, initial version is set
+  if (!versionsMetadata.versions) {
+    tools.logSuccess(`No historical version found : version = ${version}`);
+    version += '.0';
+
+  } else {
+    // check if the root version already exsists
+    const prevVersions = versionsMetadata.versions.filter((v) => {
+      return v.name.indexOf(version) > -1;
+    });
+
+    // do the increment over the last version found having the same root version
+    if (prevVersions.length) {
+      const lastVersion = prevVersions[prevVersions.length - 1];
+
+      if (lastVersion) {
+        tools.logInfo(`Version already found [${lastVersion.name}]`);
+        version = semver.inc(lastVersion.name, 'prerelease');
+        tools.logSuccess(`Final version : ${version}`);
+      }
+
+      // if it's a branch new DEV stream release, the snapshot is itialized
+    } else {
+      version += '.0';
+    }
+  }
+
+  return version;
+}
+
+const getNewVersionForProd = (versionsMetadata, envsMetadata) => {
+  let version;
+
+  // get the last DEV version from env metadata
+  const lastAccVersion = envsMetadata['ACC'].version;
+
+  tools.logInfo(`Fetched last version from ACC : ${lastAccVersion}`);
+
+  // coerce the version (X.Y.Z-INT.n will generate : X.Y.Z)
+  const rootVersion = semver.coerce(lastAccVersion).raw;
+  const tempVersion = rootVersion.split('.');
+  const rootVersionMinor = `${tempVersion[0]}.${tempVersion[1]}`;
+
+  // check if the root version already exists
+  const prevVersions = versionsMetadata.versions.filter((v) => {
+    return v.name.indexOf(rootVersionMinor) > -1 && v.envTarget === 'PROD';
+  });
+
+  if (prevVersions.length) {
+    const lastVersion = prevVersions[prevVersions.length - 1];
+
+    tools.logInfo(`Version already found [${lastVersion.name}]`);
+    version = semver.inc(lastVersion.name, 'patch');
+    tools.logInfo(`Incremented version : ${version}`);
+
+  } else {
+    version = rootVersion;
+  }
+
+  tools.logSuccess(`Final version : ${version}`);
+
+  return version;
+}
+
+
+const getNewVersionForEnv = (versionsMetadata, envsMetadata, rootEnv, envTarget) => {
+  let version;
+
+  tools.logInfo(`Fetching version from rootEnv: ${rootEnv} for target: ${envTarget}`);
+
+  // check if envMetadata contains data for the rootEnv
+  if (!envsMetadata[rootEnv]) {
+    throw new Error(`No metadata found for rootEnv: ${rootEnv} for envTarget build: ${envTarget}`);
+  }
+
+  // get the last DEV version from env metadata
+  const lastRootEnvVersion = envsMetadata[rootEnv].version;
+
+  tools.logInfo(`Fetched last version from ${rootEnv} : ${lastRootEnvVersion}`);
+
+  // coerce the version (X.Y.Z-SNAPSHOT will generate : X.Y.Z)
+  const rootVersion = semver.coerce(lastRootEnvVersion).raw;
+
+  // check if the root version already exists
+  const prevVersions = versionsMetadata.versions.filter((v) => {
+    return v.name.indexOf(rootVersion) > -1 && v.envTarget === envTarget;
+  });
+
+  if (prevVersions.length) {
+    const lastVersion = prevVersions[prevVersions.length - 1];
+
+    tools.logInfo(`Version already found [${lastVersion.name}]`);
+    version = semver.inc(lastVersion.name, 'prerelease');
+    tools.logInfo(`Incremented version : ${version}`);
+
+  } else {
+    version = rootVersion + '-' + envTarget + '.0';
+  }
+
+  tools.logSuccess(`Final version : ${version}`);
+
+  return version;
+}
+
+
+
+
+module.exports.getNewVersionDefault = (envTarget, versionsMetadata, envsMetadata) => {
+  tools.logInfo(`Retrieve version for ${envTarget}`);
+
+  return Promise.resolve()
+    .then(() => {
+      let version;
+
+      // =====================================================================
+      // DEV target : format : X.Y.Z-SNAPSHOT.n
+      //  - where X.Y.Z is last INT release next MAJOR version
+      // =====================================================================
+
+      if (envTarget === 'DEV') {
+        version = getNewVersionForDev(versionsMetadata, envsMetadata, 'INT');
+      }
+
+
+      // =====================================================================
+      // TST target : format : X.Y.Z-TST.n
+      //   - where X.Y.Z is the last root version of DEV env target
+      // =====================================================================
+
+      if (envTarget === 'TST') {
+        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'DEV', 'TST');
+      }
+
+
+      // =====================================================================
+      // INT target : format : X.Y.Z-INT.n
+      //   - where X.Y.Z is the last root version of TST env target
+      // =====================================================================
+
+      if (envTarget === 'INT') {
+        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'TST', 'INT');
+      }
+
+
+      // =====================================================================
+      // ACC target : format : X.Y.Z-envTarget.n
+      //   - where X.Y.Z is the last root version of INT env target
+      // =====================================================================
+
+      if (envTarget === 'ACC') {
+        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'INT', 'ACC');
+      }
+
+      // =====================================================================
+      // DLT targets : format : X.Y.Z-envTarget.n
+      //   - where X.Y.Z is the last root version of ACC env target
+      // =====================================================================
+
+      if (envTarget === 'DLT') {
+        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'ACC', 'DLT');
+      }
+
+      // =====================================================================
+      // TRN targets : format : X.Y.Z-envTarget.n
+      //   - where X.Y.Z is the last root version of PROD env target
+      // =====================================================================
+
+      if (envTarget === 'TRN') {
+        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'ACC', 'TRN');
+      }
+
+      // =====================================================================
+      // FOR PROD : format X.Y.Z(+1)
+      //   - where X.Y.Z is the last version of PROD with the same INT root
+      // =====================================================================
+
+      if (envTarget === 'PROD') {
+        version = getNewVersionForProd(versionsMetadata, envsMetadata);
+      }
+
+      // Check if version has been found, it can never be empty
+      if (!version) {
+        throw new Error(`Unable to generate version for ${envTarget}`);
+      }
+
+      return version;
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+module.exports.getNewVersionDTAP = (envTarget, versionsMetadata, envsMetadata) => {
+  tools.logInfo(`Retrieve version for ${envTarget}`);
+
+  return Promise.resolve()
+    .then(() => {
+      let version;
+
+      // =====================================================================
+      // DEV target : format : X.Y.Z-SNAPSHOT.n
+      //  - where X.Y.Z is last INT release next MAJOR version
+      // =====================================================================
+
+      if (envTarget === 'DEV') {
+        version = getNewVersionForDev(versionsMetadata, envsMetadata, 'TST');
+      }
+
+
+      // =====================================================================
+      // TST target : format : X.Y.Z-TST.n
+      //   - where X.Y.Z is the last root version of DEV env target
+      // =====================================================================
+
+      if (envTarget === 'TST') {
+        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'DEV', 'TST');
+      }
+
+
+      // =====================================================================
+      // ACC target : format : X.Y.Z-envTarget.n
+      //   - where X.Y.Z is the last root version of INT env target
+      // =====================================================================
+
+      if (envTarget === 'ACC') {
+        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'TST', 'ACC');
+      }
+
+
+      // =====================================================================
+      // FOR PROD : format X.Y.Z(+1)
+      //   - where X.Y.Z is the last version of PROD with the same INT root
+      // =====================================================================
+
+      if (envTarget === 'PROD') {
+        version = getNewVersionForProd(versionsMetadata, envsMetadata);
+      }
+
+      // Check if version has been found, it can never be empty
+      if (!version) {
+        throw new Error(`Unable to generate version for ${envTarget}`);
+      }
+
+      return version;
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+

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

@@ -0,0 +1,158 @@
+'use strict';
+
+// externals
+const semver = require('semver');
+const path = require('path');
+const execa = require('execa');
+const fs = require('fs');
+
+// local
+const tools = require('../../utils/tools');
+const templateUtils = require('../templates/template-utils');
+const configUtils = require('../config/config-utils');
+
+
+// constants
+const { dryRun, nexusUser, nexusPassword } = tools.getArgs();
+
+
+const writePackageJsonCore = (newVersion, folder, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch) => {
+  return Promise.resolve()
+    .then(() => {
+      const pkgJsonFile = path.resolve(folder, 'package.json');
+      const pkgJson = require(pkgJsonFile);
+
+      let tag;
+
+      if (isSnapshot) {
+        tag = 'snapshot';
+      } else if (isNextBranch) {
+        tag = 'next';
+      } else if (isSupportBranch) {
+        tag = 'prev';
+      } else {
+        tag = 'latest';
+      }
+
+      pkgJson.version = newVersion;
+      pkgJson.tag = tag;
+
+      tools.logInfo(`Updating package version : ${newVersion} / tag: ${tag} for ${pkgJsonFile}`);
+
+      if (!dryRun) {
+        tools.writeJsonFileSync(pkgJsonFile, pkgJson);
+      }
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+
+const writePackageJson = (pkg, newVersion, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch) => {
+  return Promise.resolve()
+    .then(() => {
+      tools.logTitle('updating package version');
+
+      if (!pkg.parent) {
+        return Promise.resolve()
+          .then(() => {
+            return writePackageJsonCore(newVersion, pkg.paths.pkgDirectory, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch);
+          })
+          .then(() => {
+            if (!pkg.element && !pkg.config) {
+              return writePackageJsonCore(newVersion, pkg.paths.pkgPublish, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch);
+            }
+          })
+          .catch((e) => {
+            throw e;
+          })
+
+      } else {
+        return Promise.resolve()
+          .then(() => {
+            return writePackageJsonCore(newVersion, pkg.paths.pkgDirectory, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch);
+          })
+          .then(() => {
+            let linkedPackages = Object.keys(pkg.packages)
+              .map(p => {
+                const pkg = configUtils.packages.getPackage(p);
+                return pkg;
+              })
+
+            return tools.removeArrayDuplicates(linkedPackages, 'name');
+          })
+
+          .then((linkedPackages) => Promise.resolve().then(() => {
+            return linkedPackages.reduce((promise, pkg) => {
+              return promise.then(() => (
+                writePackageJsonCore(newVersion, pkg.paths.pkgPublish, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch)
+              ));
+            }, Promise.resolve());
+          }))
+
+          .catch((e) => {
+            throw e;
+          })
+      }
+    })
+    .then(() => {
+      tools.logSuccess();
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+const writePomXml = (pkg, newVersion, isSnapshot, isForceTimestamp = true) => {
+
+  tools.logTitle(`updating project pom.xml version: ${newVersion}`);
+
+
+  if (dryRun) {
+      return;
+  }
+  
+  return Promise.resolve()
+    .then(() => {
+      return templateUtils.generateMavenSettings(nexusUser, nexusPassword);
+    })
+
+    .then((mavenSettingsFile) => {
+
+      tools.logInfo(`Executing mvn versions on : ${pkg.paths.pkgDirectory}`);
+
+      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 });
+
+      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');
+        fs.writeFileSync(tsversionFile, Date.now());
+
+        const versionFile = path.resolve(pkg.paths.pkgDirectory, '.version.properties');
+        fs.writeFileSync(versionFile, newVersion);
+      }
+    })
+    .then(() => {
+      tools.logSuccess();
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+module.exports.updateVersion = (pkg, newVersion, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch) => {
+  if (pkg.backend) {
+    return writePomXml(pkg, newVersion, isSnapshot);
+  }
+  else {
+    return writePackageJson(pkg, newVersion, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch);
+  }
+}
+
+

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

@@ -0,0 +1,144 @@
+'use strict';
+
+// externals
+const semver = require('semver');
+const path = require('path');
+
+// local
+const tools = require('../../utils/tools');
+
+
+const getCurrentVersion = (pkg) => {
+  return Promise.resolve()
+    .then(() => {
+      let currentVersion;
+
+      tools.logTitle('Extracting current version');
+
+      if (pkg.backend) {
+        // if nodejs backend, explicitely declared
+        if (pkg.build && pkg.build.nodejs) {
+          tools.logInfo('UI package => extracting from package.json');
+
+          const pathPkgJson = path.resolve(pkg.paths.pkgDirectory, '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'));
+
+          tools.logInfo('Content found:');
+          console.log(xmlContent);
+
+          currentVersion = xmlContent.project.version.toString();
+        }
+
+      } else {
+        tools.logInfo('UI package => extracting from package.json');
+
+        const pathPkgJson = path.resolve(pkg.paths.pkgDirectory, 'package.json');
+        const pkgJson = require(pathPkgJson);
+        currentVersion = pkgJson.version;
+      }
+
+      tools.logSuccess('Current version found : ' + currentVersion);
+      return currentVersion;
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+const getReleaseType = (commitsMetadata) => {
+  tools.logInfo('Getting release type based on commits metadata parsed from last tag');
+
+  const RELEASE_TYPES = ['major', 'minor', 'patch'];
+
+  let level = 2;
+  let breakings = 0;
+  let features = 0;
+
+  commitsMetadata.forEach((commit) => {
+    if (commit.breakingChange) {
+      breakings += commit.body;
+      level = 1; // no major bump on "breaking changes"
+    } else if (commit.type === 'feat') {
+      features += 1;
+      if (level === 2) {
+        level = 1;
+      }
+    }
+  });
+
+  return {
+    level: level,
+    reason: 'There are ' + breakings + ' BREAKING CHANGES and ' + features + ' features',
+    releaseType: RELEASE_TYPES[level]
+  };
+}
+
+
+// PUBLIC METHODS
+
+module.exports.getNewVersion = (
+    pkg,
+    commits,
+    isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch
+  ) => {
+  return Promise.resolve()
+    .then(() => {
+      return getCurrentVersion(pkg);
+    })
+
+    .then((currentVersion) => {
+      tools.logTitle('Extracting recommended version');
+
+      tools.logInfo(`Current version found : ${currentVersion}`);
+
+      const release = getReleaseType(commits);
+      tools.logInfo('release info found : ' + JSON.stringify(release));
+
+      let newVersion = '1.0.0';
+
+      if (isNextBranch) {
+        newVersion = semver.inc(currentVersion, 'prerelease');
+      } else {
+        newVersion = semver.valid(release.releaseType) || semver.inc(currentVersion, release.releaseType)
+      }
+
+      tools.logInfo('probable new version : ' + newVersion);
+
+      if (isSnapshot) {
+        if (pkg.backend) {
+          if (pkg.build && pkg.build.nodejs) {
+            newVersion += '-snapshot-' + Date.now();
+          } else {
+            newVersion += '-SNAPSHOT';
+          }
+        } else {
+          newVersion += '-snapshot-' + Date.now();
+        }
+
+      } else if (isSupportBranch) {
+        if (pkg.backend) {
+          newVersion = semver.inc(currentVersion, 'prerelease');
+        }
+      } else if (isHotfixBranch) {
+        newVersion = semver.inc(currentVersion, 'prerelease');
+      }
+
+      tools.logSuccess('new version generated : ' + newVersion);
+
+      return newVersion;
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+

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

@@ -0,0 +1,51 @@
+'use strict';
+
+// externals
+const semver = require('semver');
+const path = require('path');
+const execa = require('execa');
+const fs = require('fs');
+
+// local
+const tools = require('../../utils/tools');
+const metadataUtils = require('../metadata/metadata-utils');
+
+// inner modules
+const innerCommon = require('./common');
+
+// constants
+const { dryRun } = tools.getArgs();
+
+
+// for env-based build, we take the latest TST release version as the base
+module.exports.getNewVersion = (pkg, envTarget) => {
+  let versionsMetadata;
+  let envsMetadata;
+
+  return Promise.resolve()
+    // fetch versions history and store
+    .then(() => {
+      return metadataUtils.packageVersions.getMetadata(pkg);
+    })
+    .then((metadata) => {
+      versionsMetadata = metadata;
+    })
+
+    // fetch envs metadata and store
+    .then(() => {
+      return metadataUtils.packageEnvs.getMetadata(pkg);
+    })
+    .then((metadata) => {
+      envsMetadata = metadata;
+    })
+
+
+    // generating new version based on the env target and the envs cycle type
+    .then(() => {
+      return innerCommon.getNewVersionDefault(envTarget, versionsMetadata, envsMetadata);
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}