@eui/tools 5.0.0-rc.8 → 5.1.1

package/scripts/csdr/version/{app-env-target.test.js → common.test.js}

@@ -1,20 +1,25 @@
-const appEnvTarget = require('./app-env-target');
+const common = require('./common');
+const { expect, assert } = require('chai');
+
+const emptyVersionsMetadata = {};
 
 const versionsMetadata = {
   "versions": [
     {
-      "name": "118.0.0-SNAPSHOT.13",
+      "version": "118.0.0-SNAPSHOT.13",
       "releaseDate": "01/01/2019 00:00",
       "envTarget": "DEV"
     },
     {
-      "name": "117.0.0-TST.0",
+      "version": "117.0.0-TST.0",
       "releaseDate": "01/01/2019 00:00",
       "envTarget": "TST"
     }
   ]
 };
 
+const emptyEnvsMetadata = {};
+
 const envsMetadata = {
   "DEV": {
       "version": "118.0.0-SNAPSHOT.13",
@@ -74,10 +79,10 @@ const envsMetadata = {
 
 describe('[CSDR-version-app-env-target] - getNewVersionDefault()', () => {
 
-  test('should fail if envTarget is empty/null/undefined', () => {
-    return appEnvTarget.getNewVersionDefault()
+  it('should fail if envTarget is empty/null/undefined', () => {
+    return common.getNewVersionDefault()
       .catch((e) => {
-        expect(e).not.toBeUndefined();
+        expect(e).not.to.be.undefined;
       })
   })
 
@@ -104,89 +109,96 @@ describe('[CSDR-version-app-env-target] - getNewVersionDefault()', () => {
   * DLT 3.0.0-DLT.0 = PROD
   */
 
-  test('version for DEV should return INT raw major + 1', () => {
-    return appEnvTarget.getNewVersionDefault('DEV', versionsMetadata, envsMetadata)
+  it('version for DEV should initialize when no envsMetadata and no versionsMetadata', () => {
+    return common.getNewVersionDefault('DEV', emptyVersionsMetadata, emptyEnvsMetadata)
+      .then((version) => {
+        expect(version).to.equal('1.0.0-SNAPSHOT.0');
+      })
+  })
+
+  it('version for DEV should return INT raw major + 1', () => {
+    return common.getNewVersionDefault('DEV', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('118.0.0-SNAPSHOT.14');
+        expect(version).to.equal('118.0.0-SNAPSHOT.14');
       })
   })
 
-  test('version for TST should return DEV raw major', () => {
-    return appEnvTarget.getNewVersionDefault('TST', versionsMetadata, envsMetadata)
+  it('version for TST should return DEV raw major', () => {
+    return common.getNewVersionDefault('TST', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('118.0.0-TST.0');
+        expect(version).to.equal('118.0.0-TST.0');
       })
   })
 
-  test('version for INT should return TST raw major', () => {
-    return appEnvTarget.getNewVersionDefault('INT', versionsMetadata, envsMetadata)
+  it('version for INT should return TST raw major', () => {
+    return common.getNewVersionDefault('INT', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('117.0.0-INT.0');
+        expect(version).to.equal('117.0.0-INT.0');
       })
   })
 
-  test('version for ACC should return INT raw major', () => {
-    return appEnvTarget.getNewVersionDefault('ACC', versionsMetadata, envsMetadata)
+  it('version for ACC should return INT raw major', () => {
+    return common.getNewVersionDefault('ACC', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('117.0.0-ACC.0');
+        expect(version).to.equal('117.0.0-ACC.0');
       })
   })
 
-  test('version for PROD should return ACC raw major', () => {
-    return appEnvTarget.getNewVersionDefault('PROD', versionsMetadata, envsMetadata)
+  it('version for PROD should return ACC raw major', () => {
+    return common.getNewVersionDefault('PROD', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('117.0.0');
+        expect(version).to.equal('117.0.0');
       })
   })
 
-  test('version for PROD should return ACC raw major, increment if x.0.0 already exits to next patch version x.0.1', () => {
+  it('version for PROD should return ACC raw major, increment if x.0.0 already exits to next patch version x.0.1', () => {
     const versionsMetadata = {
       "versions": [
         {
-          "name": "117.0.0",
+          "version": "117.0.0",
           "releaseDate": "01/01/2019 00:00",
           "envTarget": "PROD"
         },
       ]
     };
-    return appEnvTarget.getNewVersionDefault('PROD', versionsMetadata, envsMetadata)
+    return common.getNewVersionDefault('PROD', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('117.0.1');
+        expect(version).to.equal('117.0.1');
       })
   })
 
-  test('version for PROD should return ACC raw major, increment if x.0.1 already exist to next patch version x.0.2', () => {
+  it('version for PROD should return ACC raw major, increment if x.0.1 already exist to next patch version x.0.2', () => {
     const versionsMetadata = {
       "versions": [
         {
-          "name": "117.0.0",
+          "version": "117.0.0",
           "releaseDate": "01/01/2019 00:00",
           "envTarget": "PROD"
         },
         {
-          "name": "117.0.1",
+          "version": "117.0.1",
           "releaseDate": "01/01/2019 00:00",
           "envTarget": "PROD"
         }
       ]
     };
-    return appEnvTarget.getNewVersionDefault('PROD', versionsMetadata, envsMetadata)
+    return common.getNewVersionDefault('PROD', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('117.0.2');
+        expect(version).to.equal('117.0.2');
       })
   })
 
-  test('version for DLT should return ACC raw major', () => {
-    return appEnvTarget.getNewVersionDefault('DLT', versionsMetadata, envsMetadata)
+  it('version for DLT should return ACC raw major', () => {
+    return common.getNewVersionDefault('DLT', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('117.0.0-DLT.0');
+        expect(version).to.equal('117.0.0-DLT.0');
       })
   })
 
-  test('version for TRN should return ACC raw major', () => {
-    return appEnvTarget.getNewVersionDefault('TRN', versionsMetadata, envsMetadata)
+  it('version for TRN should return ACC raw major', () => {
+    return common.getNewVersionDefault('TRN', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('117.0.0-TRN.0');
+        expect(version).to.equal('117.0.0-TRN.0');
       })
   })
 

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;
+    })
+}